|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r83533 - in branches/release: boost/atomic boost/atomic/detail libs/atomic libs/atomic/test
From: vicente.botet_at_[hidden]
Date: 2013-03-23 13:50:43
Author: viboes
Date: 2013-03-23 13:50:41 EDT (Sat, 23 Mar 2013)
New Revision: 83533
URL: http://svn.boost.org/trac/boost/changeset/83533
Log:
Atomic: merge from trunk.
Properties modified:
branches/release/boost/atomic/ (props changed)
branches/release/libs/atomic/ (props changed)
Text files modified:
branches/release/boost/atomic/atomic.hpp | 60 ++++++-
branches/release/boost/atomic/detail/base.hpp | 155 +++++++++---------
branches/release/boost/atomic/detail/cas32strong.hpp | 147 ++++++++++--------
branches/release/boost/atomic/detail/cas32weak.hpp | 175 +++++++++++----------
branches/release/boost/atomic/detail/cas64strong.hpp | 91 ++++++-----
branches/release/boost/atomic/detail/gcc-alpha.hpp | 63 ++++---
branches/release/boost/atomic/detail/gcc-armv6plus.hpp | 10
branches/release/boost/atomic/detail/gcc-cas.hpp | 10
branches/release/boost/atomic/detail/gcc-ppc.hpp | 319 +++++++++++++++++++++------------------
branches/release/boost/atomic/detail/gcc-sparcv9.hpp | 234 +++++++++++++++-------------
branches/release/boost/atomic/detail/gcc-x86.hpp | 270 +++++++++++++++++----------------
branches/release/boost/atomic/detail/generic-cas.hpp | 15 +
branches/release/boost/atomic/detail/interlocked.hpp | 24 +-
branches/release/boost/atomic/detail/linux-arm.hpp | 10
branches/release/boost/atomic/detail/windows.hpp | 243 ++++++++++++++++-------------
branches/release/libs/atomic/test/api_test_helpers.hpp | 11 +
branches/release/libs/atomic/test/native_api.cpp | 6
17 files changed, 1006 insertions(+), 837 deletions(-)
Modified: branches/release/boost/atomic/atomic.hpp
==============================================================================
--- branches/release/boost/atomic/atomic.hpp (original)
+++ branches/release/boost/atomic/atomic.hpp 2013-03-23 13:50:41 EDT (Sat, 23 Mar 2013)
@@ -2,6 +2,7 @@
#define BOOST_ATOMIC_ATOMIC_HPP
// 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
@@ -16,6 +17,10 @@
#include <boost/atomic/detail/platform.hpp>
#include <boost/atomic/detail/type-classification.hpp>
#include <boost/type_traits/is_signed.hpp>
+#if defined(BOOST_MSVC) && BOOST_MSVC < 1400
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/mpl/and.hpp>
+#endif
#ifdef BOOST_ATOMIC_HAS_PRAGMA_ONCE
#pragma once
@@ -82,23 +87,54 @@
template<typename T>
class atomic :
- public atomics::detail::base_atomic<T, typename atomics::detail::classify<T>::type, atomics::detail::storage_size_of<T>::value, boost::is_signed<T>::value >
+ public atomics::detail::base_atomic<
+ T,
+ typename atomics::detail::classify<T>::type,
+ atomics::detail::storage_size_of<T>::value,
+#if !defined(BOOST_MSVC) || BOOST_MSVC >= 1400
+ boost::is_signed<T>::value
+#else
+ // MSVC 2003 has problems instantiating is_signed on non-integral types
+ mpl::and_< boost::is_integral<T>, boost::is_signed<T> >::value
+#endif
+ >
{
private:
typedef T value_type;
- typedef atomics::detail::base_atomic<T, typename atomics::detail::classify<T>::type, atomics::detail::storage_size_of<T>::value, boost::is_signed<T>::value > super;
+ typedef atomics::detail::base_atomic<
+ T,
+ typename atomics::detail::classify<T>::type,
+ atomics::detail::storage_size_of<T>::value,
+#if !defined(BOOST_MSVC) || BOOST_MSVC >= 1400
+ boost::is_signed<T>::value
+#else
+ // MSVC 2003 has problems instantiating is_signed on non-itegral types
+ mpl::and_< boost::is_integral<T>, boost::is_signed<T> >::value
+#endif
+ > super;
public:
- atomic(void) : super() {}
- explicit atomic(const value_type & v) : super(v) {}
+ atomic(void) BOOST_NOEXCEPT : super() {}
+ BOOST_CONSTEXPR atomic(value_type v) BOOST_NOEXCEPT : super(v) {}
+
+ value_type operator=(value_type v) volatile BOOST_NOEXCEPT
+ {
+ this->store(v);
+ return v;
+ }
- atomic & operator=(value_type v) volatile
+ operator value_type(void) volatile const BOOST_NOEXCEPT
{
- super::operator=(v);
- return *const_cast<atomic *>(this);
+ return this->load();
}
+
+#ifdef BOOST_NO_CXX11_DELETED_FUNCTIONS
private:
atomic(const atomic &) /* =delete */ ;
- atomic & operator=(const atomic &) /* =delete */ ;
+ atomic & operator=(const atomic &) volatile /* =delete */ ;
+#else
+ atomic(const atomic &) = delete;
+ atomic & operator=(const atomic &) volatile = delete;
+#endif
};
typedef atomic<char> atomic_char;
@@ -158,7 +194,7 @@
#if !defined(__PGIC__)
#if (defined(BOOST_WINDOWS) && !defined(_WIN32_WCE)) \
- || (defined(_XOPEN_UNIX) && (_XOPEN_UNIX+0 > 0)) \
+ || (defined(_XOPEN_UNIX) && (_XOPEN_UNIX+0 > 0) && !defined(__UCLIBC__)) \
|| defined(__CYGWIN__) \
|| defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__) \
|| defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
@@ -180,16 +216,16 @@
class atomic_flag
{
public:
- atomic_flag(void) : v_(false) {}
+ BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(false) {}
bool
- test_and_set(memory_order order = memory_order_seq_cst)
+ test_and_set(memory_order order = memory_order_seq_cst) BOOST_NOEXCEPT
{
return v_.exchange(true, order);
}
void
- clear(memory_order order = memory_order_seq_cst) volatile
+ clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
v_.store(false, order);
}
Modified: branches/release/boost/atomic/detail/base.hpp
==============================================================================
--- branches/release/boost/atomic/detail/base.hpp (original)
+++ branches/release/boost/atomic/detail/base.hpp 2013-03-23 13:50:41 EDT (Sat, 23 Mar 2013)
@@ -2,6 +2,7 @@
#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
@@ -23,23 +24,11 @@
#endif
#define BOOST_ATOMIC_DECLARE_BASE_OPERATORS \
- operator value_type(void) volatile const \
- { \
- return load(memory_order_seq_cst); \
- } \
- \
- this_type & \
- operator=(value_type v) volatile \
- { \
- store(v, memory_order_seq_cst); \
- return *const_cast<this_type *>(this); \
- } \
- \
bool \
compare_exchange_strong( \
value_type & expected, \
value_type desired, \
- memory_order order = memory_order_seq_cst) volatile \
+ memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT \
{ \
return compare_exchange_strong(expected, desired, order, calculate_failure_order(order)); \
} \
@@ -48,64 +37,63 @@
compare_exchange_weak( \
value_type & expected, \
value_type desired, \
- memory_order order = memory_order_seq_cst) volatile \
+ 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 \
+ operator++(int) volatile BOOST_NOEXCEPT \
{ \
return fetch_add(1); \
} \
\
value_type \
- operator++(void) volatile \
+ operator++(void) volatile BOOST_NOEXCEPT \
{ \
return fetch_add(1) + 1; \
} \
\
value_type \
- operator--(int) volatile \
+ operator--(int) volatile BOOST_NOEXCEPT \
{ \
return fetch_sub(1); \
} \
\
value_type \
- operator--(void) volatile \
+ operator--(void) volatile BOOST_NOEXCEPT \
{ \
return fetch_sub(1) - 1; \
} \
\
value_type \
- operator+=(difference_type v) volatile \
+ operator+=(difference_type v) volatile BOOST_NOEXCEPT \
{ \
return fetch_add(v) + v; \
} \
\
value_type \
- operator-=(difference_type v) volatile \
+ operator-=(difference_type v) volatile BOOST_NOEXCEPT \
{ \
return fetch_sub(v) - v; \
} \
#define BOOST_ATOMIC_DECLARE_BIT_OPERATORS \
value_type \
- operator&=(difference_type v) volatile \
+ operator&=(difference_type v) volatile BOOST_NOEXCEPT \
{ \
return fetch_and(v) & v; \
} \
\
value_type \
- operator|=(difference_type v) volatile \
+ operator|=(difference_type v) volatile BOOST_NOEXCEPT \
{ \
return fetch_or(v) | v; \
} \
\
value_type \
- operator^=(difference_type v) volatile \
+ operator^=(difference_type v) volatile BOOST_NOEXCEPT\
{ \
return fetch_xor(v) ^ v; \
} \
@@ -137,34 +125,37 @@
}
template<typename T, typename C, unsigned int Size, bool Sign>
-class base_atomic {
+class base_atomic
+{
private:
typedef base_atomic this_type;
typedef T value_type;
typedef lockpool::scoped_lock guard_type;
+ typedef char storage_type[sizeof(value_type)];
+
public:
base_atomic(void) {}
- explicit base_atomic(const value_type & v)
- {
- memcpy(&v_, &v, sizeof(value_type));
- }
+ 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
+ store(value_type const& v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
- guard_type guard(const_cast<char *>(v_));
+ char * storage = storage_ptr();
+ guard_type guard(storage);
- memcpy(const_cast<char *>(v_), &v, sizeof(value_type));
+ memcpy(storage, &v, sizeof(value_type));
}
value_type
- load(memory_order /*order*/ = memory_order_seq_cst) volatile const
+ load(memory_order /*order*/ = memory_order_seq_cst) volatile const BOOST_NOEXCEPT
{
- guard_type guard(const_cast<const char *>(v_));
+ char * storage = storage_ptr();
+ guard_type guard(storage);
value_type v;
- memcpy(&v, const_cast<const char *>(v_), sizeof(value_type));
+ memcpy(&v, storage, sizeof(value_type));
return v;
}
@@ -173,15 +164,16 @@
value_type & expected,
value_type const& desired,
memory_order /*success_order*/,
- memory_order /*failure_order*/) volatile
+ memory_order /*failure_order*/) volatile BOOST_NOEXCEPT
{
- guard_type guard(const_cast<char *>(v_));
+ char * storage = storage_ptr();
+ guard_type guard(storage);
- if (memcmp(const_cast<char *>(v_), &expected, sizeof(value_type)) == 0) {
- memcpy(const_cast<char *>(v_), &desired, sizeof(value_type));
+ if (memcmp(storage, &expected, sizeof(value_type)) == 0) {
+ memcpy(storage, &desired, sizeof(value_type));
return true;
} else {
- memcpy(&expected, const_cast<char *>(v_), sizeof(value_type));
+ memcpy(&expected, storage, sizeof(value_type));
return false;
}
}
@@ -191,50 +183,57 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ 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
+ exchange(value_type const& v, memory_order /*order*/=memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
- guard_type guard(const_cast<char *>(v_));
+ char * storage = storage_ptr();
+ guard_type guard(storage);
value_type tmp;
- memcpy(&tmp, const_cast<char *>(v_), sizeof(value_type));
+ memcpy(&tmp, storage, sizeof(value_type));
- memcpy(const_cast<char *>(v_), &v, sizeof(value_type));
+ memcpy(storage, &v, sizeof(value_type));
return tmp;
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return false;
}
BOOST_ATOMIC_DECLARE_BASE_OPERATORS
private:
+ char * storage_ptr() volatile const BOOST_NOEXCEPT
+ {
+ return const_cast<char *>(&reinterpret_cast<char const volatile &>(v_));
+ }
+
base_atomic(const base_atomic &) /* = delete */ ;
void operator=(const base_atomic &) /* = delete */ ;
- char v_[sizeof(value_type)];
+ T v_;
};
template<typename T, unsigned int Size, bool Sign>
-class base_atomic<T, int, Size, Sign> {
+class base_atomic<T, int, Size, Sign>
+{
private:
typedef base_atomic this_type;
typedef T value_type;
typedef T difference_type;
typedef lockpool::scoped_lock guard_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile
+ store(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
guard_type guard(const_cast<value_type *>(&v_));
@@ -242,7 +241,7 @@
}
value_type
- load(memory_order /*order*/ = memory_order_seq_cst) const volatile
+ load(memory_order /*order*/ = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
guard_type guard(const_cast<value_type *>(&v_));
@@ -251,7 +250,7 @@
}
value_type
- exchange(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
guard_type guard(const_cast<value_type *>(&v_));
@@ -263,7 +262,7 @@
bool
compare_exchange_strong(value_type & expected, value_type desired,
memory_order /*success_order*/,
- memory_order /*failure_order*/) volatile
+ memory_order /*failure_order*/) volatile BOOST_NOEXCEPT
{
guard_type guard(const_cast<value_type *>(&v_));
@@ -279,13 +278,13 @@
bool
compare_exchange_weak(value_type & expected, value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ 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
+ fetch_add(difference_type v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
guard_type guard(const_cast<value_type *>(&v_));
@@ -295,7 +294,7 @@
}
value_type
- fetch_sub(difference_type v, memory_order /*order*/ = memory_order_seq_cst) volatile
+ fetch_sub(difference_type v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
guard_type guard(const_cast<value_type *>(&v_));
@@ -305,7 +304,7 @@
}
value_type
- fetch_and(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile
+ fetch_and(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
guard_type guard(const_cast<value_type *>(&v_));
@@ -315,7 +314,7 @@
}
value_type
- fetch_or(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile
+ fetch_or(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
guard_type guard(const_cast<value_type *>(&v_));
@@ -325,7 +324,7 @@
}
value_type
- fetch_xor(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile
+ fetch_xor(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
guard_type guard(const_cast<value_type *>(&v_));
@@ -335,7 +334,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return false;
}
@@ -348,25 +347,26 @@
};
template<typename T, unsigned int Size, bool Sign>
-class base_atomic<T *, void *, Size, Sign> {
+class base_atomic<T *, void *, Size, Sign>
+{
private:
typedef base_atomic this_type;
typedef T * value_type;
typedef ptrdiff_t difference_type;
typedef lockpool::scoped_lock guard_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile
+ store(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
guard_type guard(const_cast<value_type *>(&v_));
v_ = v;
}
value_type
- load(memory_order /*order*/ = memory_order_seq_cst) const volatile
+ load(memory_order /*order*/ = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
guard_type guard(const_cast<value_type *>(&v_));
@@ -375,7 +375,7 @@
}
value_type
- exchange(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
guard_type guard(const_cast<value_type *>(&v_));
@@ -387,7 +387,7 @@
bool
compare_exchange_strong(value_type & expected, value_type desired,
memory_order /*success_order*/,
- memory_order /*failure_order*/) volatile
+ memory_order /*failure_order*/) volatile BOOST_NOEXCEPT
{
guard_type guard(const_cast<value_type *>(&v_));
@@ -403,12 +403,12 @@
bool
compare_exchange_weak(value_type & expected, value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ 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
+ value_type fetch_add(difference_type v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
guard_type guard(const_cast<value_type *>(&v_));
@@ -427,7 +427,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return false;
}
@@ -440,24 +440,25 @@
};
template<unsigned int Size, bool Sign>
-class base_atomic<void *, void *, Size, Sign> {
+class base_atomic<void *, void *, Size, Sign>
+{
private:
typedef base_atomic this_type;
typedef void * value_type;
typedef lockpool::scoped_lock guard_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile
+ store(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
guard_type guard(const_cast<value_type *>(&v_));
v_ = v;
}
value_type
- load(memory_order /*order*/ = memory_order_seq_cst) const volatile
+ load(memory_order /*order*/ = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
guard_type guard(const_cast<value_type *>(&v_));
@@ -466,7 +467,7 @@
}
value_type
- exchange(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order /*order*/ = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
guard_type guard(const_cast<value_type *>(&v_));
@@ -478,7 +479,7 @@
bool
compare_exchange_strong(value_type & expected, value_type desired,
memory_order /*success_order*/,
- memory_order /*failure_order*/) volatile
+ memory_order /*failure_order*/) volatile BOOST_NOEXCEPT
{
guard_type guard(const_cast<value_type *>(&v_));
@@ -494,13 +495,13 @@
bool
compare_exchange_weak(value_type & expected, value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return false;
}
Modified: branches/release/boost/atomic/detail/cas32strong.hpp
==============================================================================
--- branches/release/boost/atomic/detail/cas32strong.hpp (original)
+++ branches/release/boost/atomic/detail/cas32strong.hpp 2013-03-23 13:50:41 EDT (Sat, 23 Mar 2013)
@@ -6,6 +6,8 @@
// 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.
@@ -27,17 +29,18 @@
/* integral types */
template<typename T, bool Sign>
-class base_atomic<T, int, 1, Sign> {
+class base_atomic<T, int, 1, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef T difference_type;
typedef uint32_t storage_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before_store(order);
const_cast<volatile storage_type &>(v_) = v;
@@ -53,7 +56,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -66,7 +69,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
@@ -76,7 +79,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
platform_fence_before(success_order);
@@ -96,7 +99,7 @@
}
value_type
- fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -105,7 +108,7 @@
}
value_type
- fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -114,7 +117,7 @@
}
value_type
- fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -123,7 +126,7 @@
}
value_type
- fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -132,7 +135,7 @@
}
value_type
- fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -154,17 +157,18 @@
};
template<typename T, bool Sign>
-class base_atomic<T, int, 2, Sign> {
+class base_atomic<T, int, 2, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef T difference_type;
typedef uint32_t storage_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before_store(order);
const_cast<volatile storage_type &>(v_) = v;
@@ -180,7 +184,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -193,7 +197,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
@@ -203,7 +207,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
platform_fence_before(success_order);
@@ -223,7 +227,7 @@
}
value_type
- fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -232,7 +236,7 @@
}
value_type
- fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -241,7 +245,7 @@
}
value_type
- fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -250,7 +254,7 @@
}
value_type
- fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -259,7 +263,7 @@
}
value_type
- fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -281,16 +285,17 @@
};
template<typename T, bool Sign>
-class base_atomic<T, int, 4, Sign> {
+class base_atomic<T, int, 4, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef T difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before_store(order);
const_cast<volatile value_type &>(v_) = v;
@@ -306,7 +311,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -319,7 +324,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
@@ -329,7 +334,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
platform_fence_before(success_order);
@@ -345,7 +350,7 @@
}
value_type
- fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -354,7 +359,7 @@
}
value_type
- fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -363,7 +368,7 @@
}
value_type
- fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -372,7 +377,7 @@
}
value_type
- fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -381,7 +386,7 @@
}
value_type
- fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -405,16 +410,17 @@
/* pointer types */
template<bool Sign>
-class base_atomic<void *, void *, 4, Sign> {
+class base_atomic<void *, void *, 4, Sign>
+{
typedef base_atomic this_type;
typedef void * value_type;
typedef ptrdiff_t difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before_store(order);
const_cast<volatile value_type &>(v_) = v;
@@ -430,7 +436,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -443,7 +449,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
@@ -453,7 +459,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
platform_fence_before(success_order);
@@ -469,7 +475,7 @@
}
value_type
- fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -478,7 +484,7 @@
}
value_type
- fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -500,16 +506,17 @@
};
template<typename T, bool Sign>
-class base_atomic<T *, void *, 4, Sign> {
+class base_atomic<T *, void *, 4, Sign>
+{
typedef base_atomic this_type;
typedef T * value_type;
typedef ptrdiff_t difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before_store(order);
const_cast<volatile value_type &>(v_) = v;
@@ -525,7 +532,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -538,7 +545,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
@@ -548,7 +555,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
platform_fence_before(success_order);
@@ -564,7 +571,7 @@
}
value_type
- fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -573,7 +580,7 @@
}
value_type
- fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -597,19 +604,21 @@
/* generic types */
template<typename T, bool Sign>
-class base_atomic<T, void, 1, Sign> {
+class base_atomic<T, void, 1, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef uint32_t storage_type;
public:
- explicit base_atomic(value_type const& v)
+ explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
{
memcpy(&v_, &v, sizeof(value_type));
}
+
base_atomic(void) {}
void
- store(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -630,7 +639,7 @@
}
value_type
- exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type const& v, memory_order order = memory_order_seq_cst) ) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -643,7 +652,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) ) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
@@ -653,7 +662,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) ) volatile BOOST_NOEXCEPT
{
storage_type expected_s = 0, desired_s = 0;
memcpy(&expected_s, &expected, sizeof(value_type));
@@ -686,19 +695,21 @@
};
template<typename T, bool Sign>
-class base_atomic<T, void, 2, Sign> {
+class base_atomic<T, void, 2, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef uint32_t storage_type;
public:
- explicit base_atomic(value_type const& v)
+ explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
{
memcpy(&v_, &v, sizeof(value_type));
}
+
base_atomic(void) {}
void
- store(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -719,7 +730,7 @@
}
value_type
- exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type const& v, memory_order order = memory_order_seq_cst) ) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -732,7 +743,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
@@ -742,7 +753,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
storage_type expected_s = 0, desired_s = 0;
@@ -776,19 +787,21 @@
};
template<typename T, bool Sign>
-class base_atomic<T, void, 4, Sign> {
+class base_atomic<T, void, 4, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef uint32_t storage_type;
public:
- explicit base_atomic(value_type const& v) : v_(0)
+ explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
{
memcpy(&v_, &v, sizeof(value_type));
}
+
base_atomic(void) {}
void
- store(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -809,7 +822,7 @@
}
value_type
- exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -822,7 +835,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
@@ -832,7 +845,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
storage_type expected_s = 0, desired_s = 0;
Modified: branches/release/boost/atomic/detail/cas32weak.hpp
==============================================================================
--- branches/release/boost/atomic/detail/cas32weak.hpp (original)
+++ branches/release/boost/atomic/detail/cas32weak.hpp 2013-03-23 13:50:41 EDT (Sat, 23 Mar 2013)
@@ -6,6 +6,8 @@
// http://www.boost.org/LICENSE_1_0.txt)
//
// Copyright (c) 2011 Helge Bahmann
+// Copyright (c) 2013 Tim Blechmann
+
#include <cstddef>
#include <boost/cstdint.hpp>
@@ -24,17 +26,18 @@
/* integral types */
template<typename T, bool Sign>
-class base_atomic<T, int, 1, Sign> {
+class base_atomic<T, int, 1, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef T difference_type;
typedef uint32_t storage_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before_store(order);
const_cast<volatile storage_type &>(v_) = v;
@@ -42,7 +45,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v = const_cast<const volatile storage_type &>(v_);
platform_fence_after_load(order);
@@ -50,7 +53,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -63,7 +66,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
platform_fence_before(success_order);
@@ -87,7 +90,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
for(;;) {
value_type tmp = expected;
@@ -101,7 +104,7 @@
}
value_type
- fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -110,7 +113,7 @@
}
value_type
- fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -119,7 +122,7 @@
}
value_type
- fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -128,7 +131,7 @@
}
value_type
- fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -137,7 +140,7 @@
}
value_type
- fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -146,7 +149,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -159,17 +162,18 @@
};
template<typename T, bool Sign>
-class base_atomic<T, int, 2, Sign> {
+class base_atomic<T, int, 2, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef T difference_type;
typedef uint32_t storage_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before_store(order);
const_cast<volatile storage_type &>(v_) = v;
@@ -177,7 +181,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v = const_cast<const volatile storage_type &>(v_);
platform_fence_after_load(order);
@@ -185,7 +189,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -198,7 +202,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
platform_fence_before(success_order);
@@ -222,7 +226,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
for(;;) {
value_type tmp = expected;
@@ -236,7 +240,7 @@
}
value_type
- fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -245,7 +249,7 @@
}
value_type
- fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -254,7 +258,7 @@
}
value_type
- fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -263,7 +267,7 @@
}
value_type
- fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -272,7 +276,7 @@
}
value_type
- fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -281,7 +285,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -294,16 +298,17 @@
};
template<typename T, bool Sign>
-class base_atomic<T, int, 4, Sign> {
+class base_atomic<T, int, 4, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef T difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before_store(order);
const_cast<volatile value_type &>(v_) = v;
@@ -311,7 +316,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v = const_cast<const volatile value_type &>(v_);
platform_fence_after_load(order);
@@ -319,7 +324,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -332,7 +337,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
platform_fence_before(success_order);
@@ -352,7 +357,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
for(;;) {
value_type tmp = expected;
@@ -366,7 +371,7 @@
}
value_type
- fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -375,7 +380,7 @@
}
value_type
- fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -384,7 +389,7 @@
}
value_type
- fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -393,7 +398,7 @@
}
value_type
- fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -402,7 +407,7 @@
}
value_type
- fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -411,7 +416,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -426,16 +431,17 @@
/* pointer types */
template<bool Sign>
-class base_atomic<void *, void *, 4, Sign> {
+class base_atomic<void *, void *, 4, Sign>
+{
typedef base_atomic this_type;
typedef void * value_type;
typedef ptrdiff_t difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before_store(order);
const_cast<volatile value_type &>(v_) = v;
@@ -443,7 +449,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v = const_cast<const volatile value_type &>(v_);
platform_fence_after_load(order);
@@ -451,7 +457,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -464,7 +470,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
platform_fence_before(success_order);
@@ -484,7 +490,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
for(;;) {
value_type tmp = expected;
@@ -498,7 +504,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -511,16 +517,17 @@
};
template<typename T, bool Sign>
-class base_atomic<T *, void *, 4, Sign> {
+class base_atomic<T *, void *, 4, Sign>
+{
typedef base_atomic this_type;
typedef T * value_type;
typedef ptrdiff_t difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before_store(order);
const_cast<volatile value_type &>(v_) = v;
@@ -528,7 +535,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v = const_cast<const volatile value_type &>(v_);
platform_fence_after_load(order);
@@ -536,7 +543,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -549,7 +556,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
platform_fence_before(success_order);
@@ -569,7 +576,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
for(;;) {
value_type tmp = expected;
@@ -583,7 +590,7 @@
}
value_type
- fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -592,7 +599,7 @@
}
value_type
- fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -601,7 +608,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -616,19 +623,21 @@
/* generic types */
template<typename T, bool Sign>
-class base_atomic<T, void, 1, Sign> {
+class base_atomic<T, void, 1, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef uint32_t storage_type;
public:
- explicit base_atomic(value_type const& v) : v_(0)
+ explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
{
memcpy(&v_, &v, sizeof(value_type));
}
+
base_atomic(void) {}
void
- store(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -638,7 +647,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
storage_type tmp = const_cast<const volatile storage_type &>(v_);
platform_fence_after_load(order);
@@ -649,7 +658,7 @@
}
value_type
- exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -662,7 +671,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
storage_type expected_s = 0, desired_s = 0;
memcpy(&expected_s, &expected, sizeof(value_type));
@@ -687,7 +696,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
for(;;) {
value_type tmp = expected;
@@ -701,7 +710,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -714,19 +723,21 @@
};
template<typename T, bool Sign>
-class base_atomic<T, void, 2, Sign> {
+class base_atomic<T, void, 2, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef uint32_t storage_type;
public:
- explicit base_atomic(value_type const& v) : v_(0)
+ explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
{
memcpy(&v_, &v, sizeof(value_type));
}
+
base_atomic(void) {}
void
- store(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -736,7 +747,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
storage_type tmp = const_cast<const volatile storage_type &>(v_);
platform_fence_after_load(order);
@@ -747,7 +758,7 @@
}
value_type
- exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -760,7 +771,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
storage_type expected_s = 0, desired_s = 0;
memcpy(&expected_s, &expected, sizeof(value_type));
@@ -785,7 +796,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
for(;;) {
value_type tmp = expected;
@@ -799,7 +810,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -812,19 +823,21 @@
};
template<typename T, bool Sign>
-class base_atomic<T, void, 4, Sign> {
+class base_atomic<T, void, 4, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef uint32_t storage_type;
public:
- explicit base_atomic(value_type const& v) : v_(0)
+ explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
{
memcpy(&v_, &v, sizeof(value_type));
}
+
base_atomic(void) {}
void
- store(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -834,7 +847,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
storage_type tmp = const_cast<const volatile storage_type &>(v_);
platform_fence_after_load(order);
@@ -845,7 +858,7 @@
}
value_type
- exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -858,7 +871,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
storage_type expected_s = 0, desired_s = 0;
memcpy(&expected_s, &expected, sizeof(value_type));
@@ -883,7 +896,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
for(;;) {
value_type tmp = expected;
@@ -897,7 +910,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
Modified: branches/release/boost/atomic/detail/cas64strong.hpp
==============================================================================
--- branches/release/boost/atomic/detail/cas64strong.hpp (original)
+++ branches/release/boost/atomic/detail/cas64strong.hpp 2013-03-23 13:50:41 EDT (Sat, 23 Mar 2013)
@@ -6,6 +6,7 @@
// http://www.boost.org/LICENSE_1_0.txt)
//
// Copyright (c) 2011 Helge Bahmann
+// Copyright (c) 2013 Tim Blechmann
// Build 64-bit atomic operation from platform_cmpxchg64_strong
// primitive. It is assumed that 64-bit loads/stores are not
@@ -28,16 +29,17 @@
/* integral types */
template<typename T, bool Sign>
-class base_atomic<T, int, 8, Sign> {
+class base_atomic<T, int, 8, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef T difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before_store(order);
platform_store64(v, &v_);
@@ -45,7 +47,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v = platform_load64(&v_);
platform_fence_after_load(order);
@@ -53,7 +55,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -66,7 +68,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
@@ -76,7 +78,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
platform_fence_before(success_order);
@@ -92,7 +94,7 @@
}
value_type
- fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -101,7 +103,7 @@
}
value_type
- fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -110,7 +112,7 @@
}
value_type
- fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -119,7 +121,7 @@
}
value_type
- fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -128,7 +130,7 @@
}
value_type
- fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -137,7 +139,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -152,16 +154,17 @@
/* pointer types */
template<bool Sign>
-class base_atomic<void *, void *, 8, Sign> {
+class base_atomic<void *, void *, 8, Sign>
+{
typedef base_atomic this_type;
typedef void * value_type;
typedef ptrdiff_t difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before_store(order);
platform_store64(v, &v_);
@@ -169,7 +172,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v = platform_load64(&v_);
platform_fence_after_load(order);
@@ -177,7 +180,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -190,7 +193,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
@@ -200,7 +203,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
platform_fence_before(success_order);
@@ -216,7 +219,7 @@
}
value_type
- fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -225,7 +228,7 @@
}
value_type
- fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -234,7 +237,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -247,16 +250,17 @@
};
template<typename T, bool Sign>
-class base_atomic<T *, void *, 8, Sign> {
+class base_atomic<T *, void *, 8, Sign>
+{
typedef base_atomic this_type;
typedef T * value_type;
typedef ptrdiff_t difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before_store(order);
platform_store64(v, &v_);
@@ -264,7 +268,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v = platform_load64(&v_);
platform_fence_after_load(order);
@@ -272,7 +276,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -285,7 +289,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
@@ -295,7 +299,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
platform_fence_before(success_order);
@@ -311,7 +315,7 @@
}
value_type
- fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -320,7 +324,7 @@
}
value_type
- fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -329,7 +333,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -344,39 +348,40 @@
/* generic types */
template<typename T, bool Sign>
-class base_atomic<T, void, 8, Sign> {
+class base_atomic<T, void, 8, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef uint64_t storage_type;
public:
- explicit base_atomic(value_type const& v) : v_(0)
+ explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
{
memcpy(&v_, &v, sizeof(value_type));
}
base_atomic(void) {}
void
- store(value_type const& value, memory_order order = memory_order_seq_cst) volatile
+ 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_s));
+ 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
+ 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_s));
+ memcpy(&value, &value_s, sizeof(value_type));
return value;
}
value_type
- exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original = load(memory_order_relaxed);
do {
@@ -389,7 +394,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
@@ -399,7 +404,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
storage_type expected_s = 0, desired_s = 0;
memcpy(&expected_s, &expected, sizeof(value_type));
@@ -419,7 +424,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
Modified: branches/release/boost/atomic/detail/gcc-alpha.hpp
==============================================================================
--- branches/release/boost/atomic/detail/gcc-alpha.hpp (original)
+++ branches/release/boost/atomic/detail/gcc-alpha.hpp 2013-03-23 13:50:41 EDT (Sat, 23 Mar 2013)
@@ -2,6 +2,7 @@
#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
@@ -87,18 +88,19 @@
}
template<typename T>
-class atomic_alpha_32 {
+class atomic_alpha_32
+{
public:
typedef T integral_type;
- explicit atomic_alpha_32(T v) : i(v) {}
+ 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
+ T load(memory_order order=memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
T v=*reinterpret_cast<volatile const int *>(&i);
fence_after(order);
return v;
}
- void store(T v, memory_order order=memory_order_seq_cst) volatile
+ void store(T v, memory_order order=memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
fence_before(order);
*reinterpret_cast<volatile int *>(&i)=(int)v;
@@ -107,7 +109,7 @@
T &expected,
T desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
fence_before(success_order);
int current, success;
@@ -133,9 +135,9 @@
return desired;
}
- bool is_lock_free(void) const volatile {return true;}
+ bool is_lock_free(void) const volatile BOOST_NOEXCEPT {return true;}
protected:
- inline T fetch_add_var(T c, memory_order order) volatile
+ inline T fetch_add_var(T c, memory_order order) volatile BOOST_NOEXCEPT
{
fence_before(order);
T original, modified;
@@ -156,7 +158,7 @@
fence_after(order);
return original;
}
- inline T fetch_inc(memory_order order) volatile
+ inline T fetch_inc(memory_order order) volatile BOOST_NOEXCEPT
{
fence_before(order);
int original, modified;
@@ -177,7 +179,7 @@
fence_after(order);
return original;
}
- inline T fetch_dec(memory_order order) volatile
+ inline T fetch_dec(memory_order order) volatile BOOST_NOEXCEPT
{
fence_before(order);
int original, modified;
@@ -203,10 +205,11 @@
};
template<typename T>
-class atomic_alpha_64 {
+class atomic_alpha_64
+{
public:
typedef T integral_type;
- explicit atomic_alpha_64(T v) : i(v) {}
+ 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
{
@@ -214,7 +217,7 @@
fence_after(order);
return v;
}
- void store(T v, memory_order order=memory_order_seq_cst) volatile
+ void store(T v, memory_order order=memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
fence_before(order);
*reinterpret_cast<volatile T *>(&i)=v;
@@ -223,7 +226,7 @@
T &expected,
T desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
fence_before(success_order);
int current, success;
@@ -249,9 +252,9 @@
return desired;
}
- bool is_lock_free(void) const volatile {return true;}
+ bool is_lock_free(void) const volatile BOOST_NOEXCEPT {return true;}
protected:
- inline T fetch_add_var(T c, memory_order order) volatile
+ inline T fetch_add_var(T c, memory_order order) volatile BOOST_NOEXCEPT
{
fence_before(order);
T original, modified;
@@ -272,7 +275,7 @@
fence_after(order);
return original;
}
- inline T fetch_inc(memory_order order) volatile
+ inline T fetch_inc(memory_order order) volatile BOOST_NOEXCEPT
{
fence_before(order);
T original, modified;
@@ -293,7 +296,7 @@
fence_after(order);
return original;
}
- inline T fetch_dec(memory_order order) volatile
+ inline T fetch_dec(memory_order order) volatile BOOST_NOEXCEPT
{
fence_before(order);
T original, modified;
@@ -319,36 +322,42 @@
};
template<typename T>
-class platform_atomic_integral<T, 4> : public build_atomic_from_typical<build_exchange<atomic_alpha_32<T> > > {
+class platform_atomic_integral<T, 4> :
+ public build_atomic_from_typical<build_exchange<atomic_alpha_32<T> > >
+{
public:
typedef build_atomic_from_typical<build_exchange<atomic_alpha_32<T> > > super;
- explicit platform_atomic_integral(T v) : super(v) {}
+ BOOST_CONSTEXPR platform_atomic_integral(T v) BOOST_NOEXCEPT: super(v) {}
platform_atomic_integral(void) {}
};
template<typename T>
-class platform_atomic_integral<T, 8> : public build_atomic_from_typical<build_exchange<atomic_alpha_64<T> > > {
+class platform_atomic_integral<T, 8> :
+ public build_atomic_from_typical<build_exchange<atomic_alpha_64<T> > >
+{
public:
typedef build_atomic_from_typical<build_exchange<atomic_alpha_64<T> > > super;
- explicit platform_atomic_integral(T v) : super(v) {}
+ BOOST_CONSTEXPR platform_atomic_integral(T v) BOOST_NOEXCEPT: super(v) {}
platform_atomic_integral(void) {}
};
template<typename T>
-class platform_atomic_integral<T, 1>: public build_atomic_from_larger_type<atomic_alpha_32<uint32_t>, T> {
+class platform_atomic_integral<T, 1> :
+ public build_atomic_from_larger_type<atomic_alpha_32<uint32_t>, T>
+{
public:
typedef build_atomic_from_larger_type<atomic_alpha_32<uint32_t>, T> super;
-
- explicit platform_atomic_integral(T v) : super(v) {}
+ BOOST_CONSTEXPR platform_atomic_integral(T v) BOOST_NOEXCEPT: super(v) {}
platform_atomic_integral(void) {}
};
template<typename T>
-class platform_atomic_integral<T, 2>: public build_atomic_from_larger_type<atomic_alpha_32<uint32_t>, T> {
+class platform_atomic_integral<T, 2> :
+ public build_atomic_from_larger_type<atomic_alpha_32<uint32_t>, T>
+{
public:
typedef build_atomic_from_larger_type<atomic_alpha_32<uint32_t>, T> super;
-
- explicit platform_atomic_integral(T v) : super(v) {}
+ BOOST_CONSTEXPR platform_atomic_integral(T v) BOOST_NOEXCEPT: super(v) {}
platform_atomic_integral(void) {}
};
Modified: branches/release/boost/atomic/detail/gcc-armv6plus.hpp
==============================================================================
--- branches/release/boost/atomic/detail/gcc-armv6plus.hpp (original)
+++ branches/release/boost/atomic/detail/gcc-armv6plus.hpp 2013-03-23 13:50:41 EDT (Sat, 23 Mar 2013)
@@ -7,6 +7,7 @@
//
// 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 <cstddef>
@@ -191,16 +192,17 @@
__asm__ __volatile__ ("" ::: "memory");
}
-class atomic_flag {
+class atomic_flag
+{
private:
atomic_flag(const atomic_flag &) /* = delete */ ;
atomic_flag & operator=(const atomic_flag &) /* = delete */ ;
uint32_t v_;
public:
- atomic_flag(void) : v_(false) {}
+ BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {}
void
- clear(memory_order order = memory_order_seq_cst) volatile
+ clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
atomics::detail::platform_fence_before_store(order);
const_cast<volatile uint32_t &>(v_) = 0;
@@ -208,7 +210,7 @@
}
bool
- test_and_set(memory_order order = memory_order_seq_cst) volatile
+ test_and_set(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
atomics::detail::platform_fence_before(order);
uint32_t expected = v_;
Modified: branches/release/boost/atomic/detail/gcc-cas.hpp
==============================================================================
--- branches/release/boost/atomic/detail/gcc-cas.hpp (original)
+++ branches/release/boost/atomic/detail/gcc-cas.hpp 2013-03-23 13:50:41 EDT (Sat, 23 Mar 2013)
@@ -1,4 +1,5 @@
// 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
@@ -101,16 +102,17 @@
return success;
}
-class atomic_flag {
+class atomic_flag
+{
private:
atomic_flag(const atomic_flag &) /* = delete */ ;
atomic_flag & operator=(const atomic_flag &) /* = delete */ ;
uint32_t v_;
public:
- atomic_flag(void) : v_(false) {}
+ BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {}
void
- clear(memory_order order = memory_order_seq_cst) volatile
+ clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
atomics::detail::platform_fence_before_store(order);
const_cast<volatile uint32_t &>(v_) = 0;
@@ -118,7 +120,7 @@
}
bool
- test_and_set(memory_order order = memory_order_seq_cst) volatile
+ test_and_set(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
atomics::detail::platform_fence_before(order);
uint32_t expected = v_;
Modified: branches/release/boost/atomic/detail/gcc-ppc.hpp
==============================================================================
--- branches/release/boost/atomic/detail/gcc-ppc.hpp (original)
+++ branches/release/boost/atomic/detail/gcc-ppc.hpp 2013-03-23 13:50:41 EDT (Sat, 23 Mar 2013)
@@ -2,6 +2,7 @@
#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
@@ -104,16 +105,17 @@
}
}
-class atomic_flag {
+class atomic_flag
+{
private:
atomic_flag(const atomic_flag &) /* = delete */ ;
atomic_flag & operator=(const atomic_flag &) /* = delete */ ;
uint32_t v_;
public:
- atomic_flag(void) : v_(false) {}
+ BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {}
void
- clear(memory_order order = memory_order_seq_cst) volatile
+ clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
atomics::detail::ppc_fence_before(order);
const_cast<volatile uint32_t &>(v_) = 0;
@@ -121,7 +123,7 @@
}
bool
- test_and_set(memory_order order = memory_order_seq_cst) volatile
+ test_and_set(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
uint32_t original;
atomics::detail::ppc_fence_before(order);
@@ -195,17 +197,18 @@
/* integral types */
template<typename T>
-class base_atomic<T, int, 1, true> {
+class base_atomic<T, int, 1, true>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef int32_t storage_type;
typedef T difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
ppc_fence_before(order);
__asm__ (
@@ -217,7 +220,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v;
__asm__ __volatile__ (
@@ -233,7 +236,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original;
ppc_fence_before(order);
@@ -255,7 +258,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
int success;
ppc_fence_before(success_order);
@@ -284,7 +287,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
int success;
ppc_fence_before(success_order);
@@ -310,7 +313,7 @@
}
value_type
- fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -329,7 +332,7 @@
}
value_type
- fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -348,7 +351,7 @@
}
value_type
- fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -366,7 +369,7 @@
}
value_type
- fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -384,7 +387,7 @@
}
value_type
- fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -402,7 +405,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -415,17 +418,18 @@
};
template<typename T>
-class base_atomic<T, int, 1, false> {
+class base_atomic<T, int, 1, false>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef uint32_t storage_type;
typedef T difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
ppc_fence_before(order);
__asm__ (
@@ -437,7 +441,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v;
__asm__ __volatile__ (
@@ -453,7 +457,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original;
ppc_fence_before(order);
@@ -475,7 +479,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
int success;
ppc_fence_before(success_order);
@@ -505,7 +509,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
int success;
ppc_fence_before(success_order);
@@ -531,7 +535,7 @@
}
value_type
- fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -550,7 +554,7 @@
}
value_type
- fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -569,7 +573,7 @@
}
value_type
- fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -587,7 +591,7 @@
}
value_type
- fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -605,7 +609,7 @@
}
value_type
- fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -623,7 +627,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -636,17 +640,18 @@
};
template<typename T>
-class base_atomic<T, int, 2, true> {
+class base_atomic<T, int, 2, true>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef int32_t storage_type;
typedef T difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
ppc_fence_before(order);
__asm__ (
@@ -658,7 +663,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v;
__asm__ __volatile__ (
@@ -674,7 +679,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original;
ppc_fence_before(order);
@@ -696,7 +701,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
int success;
ppc_fence_before(success_order);
@@ -726,7 +731,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
int success;
ppc_fence_before(success_order);
@@ -752,7 +757,7 @@
}
value_type
- fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -771,7 +776,7 @@
}
value_type
- fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -790,7 +795,7 @@
}
value_type
- fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -808,7 +813,7 @@
}
value_type
- fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -826,7 +831,7 @@
}
value_type
- fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -844,7 +849,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -857,17 +862,18 @@
};
template<typename T>
-class base_atomic<T, int, 2, false> {
+class base_atomic<T, int, 2, false>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef uint32_t storage_type;
typedef T difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
ppc_fence_before(order);
__asm__ (
@@ -879,7 +885,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v;
__asm__ __volatile__ (
@@ -895,7 +901,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original;
ppc_fence_before(order);
@@ -917,7 +923,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
int success;
ppc_fence_before(success_order);
@@ -947,7 +953,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
int success;
ppc_fence_before(success_order);
@@ -973,7 +979,7 @@
}
value_type
- fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -992,7 +998,7 @@
}
value_type
- fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -1011,7 +1017,7 @@
}
value_type
- fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -1029,7 +1035,7 @@
}
value_type
- fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -1047,7 +1053,7 @@
}
value_type
- fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -1065,7 +1071,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -1078,16 +1084,17 @@
};
template<typename T, bool Sign>
-class base_atomic<T, int, 4, Sign> {
+class base_atomic<T, int, 4, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef T difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
ppc_fence_before(order);
const_cast<volatile value_type &>(v_) = v;
@@ -1095,7 +1102,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v = const_cast<const volatile value_type &>(v_);
__asm__ __volatile__ (
@@ -1111,7 +1118,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original;
ppc_fence_before(order);
@@ -1133,7 +1140,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
int success;
ppc_fence_before(success_order);
@@ -1163,7 +1170,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
int success;
ppc_fence_before(success_order);
@@ -1189,7 +1196,7 @@
}
value_type
- fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -1207,7 +1214,7 @@
}
value_type
- fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -1225,7 +1232,7 @@
}
value_type
- fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -1243,7 +1250,7 @@
}
value_type
- fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -1261,7 +1268,7 @@
}
value_type
- fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -1279,7 +1286,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -1294,16 +1301,17 @@
#if defined(__powerpc64__)
template<typename T, bool Sign>
-class base_atomic<T, int, 8, Sign> {
+class base_atomic<T, int, 8, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef T difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
ppc_fence_before(order);
const_cast<volatile value_type &>(v_) = v;
@@ -1311,7 +1319,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v = const_cast<const volatile value_type &>(v_);
__asm__ __volatile__ (
@@ -1327,7 +1335,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original;
ppc_fence_before(order);
@@ -1349,7 +1357,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
int success;
ppc_fence_before(success_order);
@@ -1379,7 +1387,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
int success;
ppc_fence_before(success_order);
@@ -1405,7 +1413,7 @@
}
value_type
- fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -1423,7 +1431,7 @@
}
value_type
- fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -1441,7 +1449,7 @@
}
value_type
- fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -1459,7 +1467,7 @@
}
value_type
- fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -1477,7 +1485,7 @@
}
value_type
- fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original, tmp;
ppc_fence_before(order);
@@ -1495,7 +1503,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -1514,15 +1522,16 @@
#if !defined(__powerpc64__)
template<bool Sign>
-class base_atomic<void *, void *, 4, Sign> {
+class base_atomic<void *, void *, 4, Sign>
+{
typedef base_atomic this_type;
typedef void * value_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
ppc_fence_before(order);
__asm__ (
@@ -1534,7 +1543,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v;
__asm__ (
@@ -1551,7 +1560,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original;
ppc_fence_before(order);
@@ -1573,7 +1582,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
int success;
ppc_fence_before(success_order);
@@ -1603,7 +1612,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
int success;
ppc_fence_before(success_order);
@@ -1629,7 +1638,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -1642,16 +1651,17 @@
};
template<typename T, bool Sign>
-class base_atomic<T *, void *, 4, Sign> {
+class base_atomic<T *, void *, 4, Sign>
+{
typedef base_atomic this_type;
typedef T * value_type;
typedef ptrdiff_t difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
ppc_fence_before(order);
__asm__ (
@@ -1663,7 +1673,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v;
__asm__ (
@@ -1680,7 +1690,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original;
ppc_fence_before(order);
@@ -1702,7 +1712,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
int success;
ppc_fence_before(success_order);
@@ -1732,7 +1742,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
int success;
ppc_fence_before(success_order);
@@ -1758,7 +1768,7 @@
}
value_type
- fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
v = v * sizeof(*v_);
value_type original, tmp;
@@ -1777,7 +1787,7 @@
}
value_type
- fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
v = v * sizeof(*v_);
value_type original, tmp;
@@ -1796,7 +1806,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -1811,15 +1821,16 @@
#else
template<bool Sign>
-class base_atomic<void *, void *, 8, Sign> {
+class base_atomic<void *, void *, 8, Sign>
+{
typedef base_atomic this_type;
typedef void * value_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
ppc_fence_before(order);
__asm__ (
@@ -1831,7 +1842,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v;
__asm__ (
@@ -1848,7 +1859,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original;
ppc_fence_before(order);
@@ -1870,7 +1881,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
int success;
ppc_fence_before(success_order);
@@ -1900,7 +1911,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
int success;
ppc_fence_before(success_order);
@@ -1926,7 +1937,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -1939,16 +1950,17 @@
};
template<typename T, bool Sign>
-class base_atomic<T *, void *, 8, Sign> {
+class base_atomic<T *, void *, 8, Sign>
+{
typedef base_atomic this_type;
typedef T * value_type;
typedef ptrdiff_t difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
ppc_fence_before(order);
__asm__ (
@@ -1960,7 +1972,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v;
__asm__ (
@@ -1977,7 +1989,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type original;
ppc_fence_before(order);
@@ -1999,7 +2011,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
int success;
ppc_fence_before(success_order);
@@ -2029,7 +2041,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
int success;
ppc_fence_before(success_order);
@@ -2055,7 +2067,7 @@
}
value_type
- fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
v = v * sizeof(*v_);
value_type original, tmp;
@@ -2074,7 +2086,7 @@
}
value_type
- fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
v = v * sizeof(*v_);
value_type original, tmp;
@@ -2093,7 +2105,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -2110,19 +2122,20 @@
/* generic */
template<typename T, bool Sign>
-class base_atomic<T, void, 1, Sign> {
+class base_atomic<T, void, 1, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef uint32_t storage_type;
public:
- explicit base_atomic(value_type const& v)
+ explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
{
memcpy(&v_, &v, sizeof(value_type));
}
base_atomic(void) {}
void
- store(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -2136,7 +2149,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
storage_type tmp;
__asm__ __volatile__ (
@@ -2156,7 +2169,7 @@
}
value_type
- exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -2181,7 +2194,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
storage_type expected_s = 0, desired_s = 0;
memcpy(&expected_s, &expected, sizeof(value_type));
@@ -2216,7 +2229,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
storage_type expected_s = 0, desired_s = 0;
memcpy(&expected_s, &expected, sizeof(value_type));
@@ -2247,7 +2260,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -2260,19 +2273,21 @@
};
template<typename T, bool Sign>
-class base_atomic<T, void, 2, Sign> {
+class base_atomic<T, void, 2, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef uint32_t storage_type;
public:
- explicit base_atomic(value_type const& v)
+ explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
{
memcpy(&v_, &v, sizeof(value_type));
}
+
base_atomic(void) {}
void
- store(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -2286,7 +2301,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
storage_type tmp;
__asm__ __volatile__ (
@@ -2306,7 +2321,7 @@
}
value_type
- exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -2331,7 +2346,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
storage_type expected_s = 0, desired_s = 0;
memcpy(&expected_s, &expected, sizeof(value_type));
@@ -2366,7 +2381,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
storage_type expected_s = 0, desired_s = 0;
memcpy(&expected_s, &expected, sizeof(value_type));
@@ -2397,7 +2412,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -2410,19 +2425,21 @@
};
template<typename T, bool Sign>
-class base_atomic<T, void, 4, Sign> {
+class base_atomic<T, void, 4, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef uint32_t storage_type;
public:
- explicit base_atomic(value_type const& v) : v_(0)
+ explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
{
memcpy(&v_, &v, sizeof(value_type));
}
+
base_atomic(void) {}
void
- store(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -2436,7 +2453,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
storage_type tmp;
__asm__ __volatile__ (
@@ -2456,7 +2473,7 @@
}
value_type
- exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -2481,7 +2498,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
storage_type expected_s = 0, desired_s = 0;
memcpy(&expected_s, &expected, sizeof(value_type));
@@ -2516,7 +2533,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
storage_type expected_s = 0, desired_s = 0;
memcpy(&expected_s, &expected, sizeof(value_type));
@@ -2547,7 +2564,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -2562,19 +2579,21 @@
#if defined(__powerpc64__)
template<typename T, bool Sign>
-class base_atomic<T, void, 8, Sign> {
+class base_atomic<T, void, 8, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef uint64_t storage_type;
public:
- explicit base_atomic(value_type const& v) : v_(0)
+ explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
{
memcpy(&v_, &v, sizeof(value_type));
}
+
base_atomic(void) {}
void
- store(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
storage_type tmp;
memcpy(&tmp, &v, sizeof(value_type));
@@ -2588,7 +2607,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
storage_type tmp;
__asm__ __volatile__ (
@@ -2608,7 +2627,7 @@
}
value_type
- exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -2633,7 +2652,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
storage_type expected_s, desired_s;
memcpy(&expected_s, &expected, sizeof(value_type));
@@ -2668,7 +2687,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
storage_type expected_s, desired_s;
memcpy(&expected_s, &expected, sizeof(value_type));
@@ -2699,7 +2718,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
Modified: branches/release/boost/atomic/detail/gcc-sparcv9.hpp
==============================================================================
--- branches/release/boost/atomic/detail/gcc-sparcv9.hpp (original)
+++ branches/release/boost/atomic/detail/gcc-sparcv9.hpp 2013-03-23 13:50:41 EDT (Sat, 23 Mar 2013)
@@ -2,6 +2,7 @@
#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
@@ -82,16 +83,17 @@
}
}
-class atomic_flag {
+class atomic_flag
+{
private:
atomic_flag(const atomic_flag &) /* = delete */ ;
atomic_flag & operator=(const atomic_flag &) /* = delete */ ;
uint32_t v_;
public:
- atomic_flag(void) : v_(false) {}
+ BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {}
void
- clear(memory_order order = memory_order_seq_cst) volatile
+ clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
atomics::detail::platform_fence_before(order);
const_cast<volatile uint32_t &>(v_) = 0;
@@ -99,7 +101,7 @@
}
bool
- test_and_set(memory_order order = memory_order_seq_cst) volatile
+ test_and_set(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
atomics::detail::platform_fence_before(order);
uint32_t tmp = 1;
@@ -173,17 +175,18 @@
/* integral types */
template<typename T>
-class base_atomic<T, int, 1, true> {
+class base_atomic<T, int, 1, true>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef T difference_type;
typedef int32_t storage_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before(order);
const_cast<volatile storage_type &>(v_) = v;
@@ -191,7 +194,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v = const_cast<const volatile storage_type &>(v_);
platform_fence_after_load(order);
@@ -199,7 +202,7 @@
}
value_type
- fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -207,7 +210,7 @@
}
value_type
- fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -215,7 +218,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -227,7 +230,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
platform_fence_before(success_order);
storage_type desired_s = desired;
@@ -252,13 +255,13 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ 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
+ 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));
@@ -266,7 +269,7 @@
}
value_type
- fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -274,7 +277,7 @@
}
value_type
- fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -282,7 +285,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -295,17 +298,18 @@
};
template<typename T>
-class base_atomic<T, int, 1, false> {
+class base_atomic<T, int, 1, false>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef T difference_type;
typedef uint32_t storage_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before(order);
const_cast<volatile storage_type &>(v_) = v;
@@ -313,7 +317,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v = const_cast<const volatile storage_type &>(v_);
platform_fence_after_load(order);
@@ -321,7 +325,7 @@
}
value_type
- fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -329,7 +333,7 @@
}
value_type
- fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -337,7 +341,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -349,7 +353,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
platform_fence_before(success_order);
storage_type desired_s = desired;
@@ -374,13 +378,13 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ 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
+ 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));
@@ -388,7 +392,7 @@
}
value_type
- fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -396,7 +400,7 @@
}
value_type
- fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -404,7 +408,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -417,17 +421,18 @@
};
template<typename T>
-class base_atomic<T, int, 2, true> {
+class base_atomic<T, int, 2, true>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef T difference_type;
typedef int32_t storage_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before(order);
const_cast<volatile storage_type &>(v_) = v;
@@ -435,7 +440,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v = const_cast<const volatile storage_type &>(v_);
platform_fence_after_load(order);
@@ -443,7 +448,7 @@
}
value_type
- fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -451,7 +456,7 @@
}
value_type
- fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -459,7 +464,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -471,7 +476,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
platform_fence_before(success_order);
storage_type desired_s = desired;
@@ -496,13 +501,13 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ 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
+ 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));
@@ -510,7 +515,7 @@
}
value_type
- fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -518,7 +523,7 @@
}
value_type
- fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -526,7 +531,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -539,17 +544,18 @@
};
template<typename T>
-class base_atomic<T, int, 2, false> {
+class base_atomic<T, int, 2, false>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef T difference_type;
typedef uint32_t storage_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before(order);
const_cast<volatile storage_type &>(v_) = v;
@@ -557,7 +563,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v = const_cast<const volatile storage_type &>(v_);
platform_fence_after_load(order);
@@ -565,7 +571,7 @@
}
value_type
- fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -573,7 +579,7 @@
}
value_type
- fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -581,7 +587,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -593,7 +599,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
platform_fence_before(success_order);
storage_type desired_s = desired;
@@ -618,13 +624,13 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ 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
+ 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));
@@ -632,7 +638,7 @@
}
value_type
- fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -640,7 +646,7 @@
}
value_type
- fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -648,7 +654,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -661,16 +667,17 @@
};
template<typename T, bool Sign>
-class base_atomic<T, int, 4, Sign> {
+class base_atomic<T, int, 4, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef T difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before(order);
const_cast<volatile value_type &>(v_) = v;
@@ -678,7 +685,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst)const volatile BOOST_NOEXCEPT
{
value_type v = const_cast<const volatile value_type &>(v_);
platform_fence_after_load(order);
@@ -686,7 +693,7 @@
}
value_type
- fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -694,7 +701,7 @@
}
value_type
- fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -702,7 +709,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -714,7 +721,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
platform_fence_before(success_order);
__asm__ (
@@ -737,13 +744,13 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ 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
+ 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));
@@ -751,7 +758,7 @@
}
value_type
- fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -759,7 +766,7 @@
}
value_type
- fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -767,7 +774,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -782,22 +789,23 @@
/* pointer types */
template<bool Sign>
-class base_atomic<void *, void *, 4, Sign> {
+class base_atomic<void *, void *, 4, Sign>
+{
typedef base_atomic this_type;
typedef void * value_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before(order);
const_cast<volatile value_type &>(v_) = v;
platform_fence_after_store(order);
}
- value_type load(memory_order order = memory_order_seq_cst) const volatile
+ value_type load(memory_order order = memory_order_seq_cst)const volatile BOOST_NOEXCEPT
{
value_type v = const_cast<const volatile value_type &>(v_);
platform_fence_after_load(order);
@@ -805,7 +813,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -817,7 +825,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
platform_fence_before(success_order);
__asm__ (
@@ -838,13 +846,13 @@
bool compare_exchange_weak(value_type & expected, value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -857,16 +865,17 @@
};
template<typename T, bool Sign>
-class base_atomic<T *, void *, 4, Sign> {
+class base_atomic<T *, void *, 4, Sign>
+{
typedef base_atomic this_type;
typedef T * value_type;
typedef ptrdiff_t difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before(order);
const_cast<volatile value_type &>(v_) = v;
@@ -874,7 +883,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst)const volatile BOOST_NOEXCEPT
{
value_type v = const_cast<const volatile value_type &>(v_);
platform_fence_after_load(order);
@@ -882,7 +891,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -894,7 +903,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
platform_fence_before(success_order);
__asm__ (
@@ -917,13 +926,13 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ 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
+ 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));
@@ -931,7 +940,7 @@
}
value_type
- fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -939,7 +948,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -954,19 +963,20 @@
/* generic types */
template<typename T, bool Sign>
-class base_atomic<T, void, 1, Sign> {
+class base_atomic<T, void, 1, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef uint32_t storage_type;
public:
- explicit base_atomic(value_type const& v) : v_(0)
+ BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
{
memcpy(&v_, &v, sizeof(value_type));
}
base_atomic(void) {}
void
- store(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -976,7 +986,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst)const volatile BOOST_NOEXCEPT
{
storage_type tmp = const_cast<volatile storage_type &>(v_);
platform_fence_after_load(order);
@@ -986,7 +996,7 @@
}
value_type
- exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -998,7 +1008,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
storage_type expected_s = 0, desired_s = 0;
memcpy(&expected_s, &expected, sizeof(value_type));
@@ -1024,13 +1034,13 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -1043,19 +1053,20 @@
};
template<typename T, bool Sign>
-class base_atomic<T, void, 2, Sign> {
+class base_atomic<T, void, 2, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef uint32_t storage_type;
public:
- explicit base_atomic(value_type const& v) : v_(0)
+ BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
{
memcpy(&v_, &v, sizeof(value_type));
}
base_atomic(void) {}
void
- store(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -1065,7 +1076,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst)const volatile BOOST_NOEXCEPT
{
storage_type tmp = const_cast<volatile storage_type &>(v_);
platform_fence_after_load(order);
@@ -1075,7 +1086,7 @@
}
value_type
- exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -1087,7 +1098,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
storage_type expected_s = 0, desired_s = 0;
memcpy(&expected_s, &expected, sizeof(value_type));
@@ -1113,13 +1124,13 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -1132,19 +1143,20 @@
};
template<typename T, bool Sign>
-class base_atomic<T, void, 4, Sign> {
+class base_atomic<T, void, 4, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef uint32_t storage_type;
public:
- explicit base_atomic(value_type const& v) : v_(0)
+ BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
{
memcpy(&v_, &v, sizeof(value_type));
}
base_atomic(void) {}
void
- store(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -1154,7 +1166,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst)const volatile BOOST_NOEXCEPT
{
storage_type tmp = const_cast<volatile storage_type &>(v_);
platform_fence_after_load(order);
@@ -1164,7 +1176,7 @@
}
value_type
- exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -1176,7 +1188,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
storage_type expected_s = 0, desired_s = 0;
memcpy(&expected_s, &expected, sizeof(value_type));
@@ -1202,13 +1214,13 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
Modified: branches/release/boost/atomic/detail/gcc-x86.hpp
==============================================================================
--- branches/release/boost/atomic/detail/gcc-x86.hpp (original)
+++ branches/release/boost/atomic/detail/gcc-x86.hpp 2013-03-23 13:50:41 EDT (Sat, 23 Mar 2013)
@@ -151,10 +151,10 @@
atomic_flag & operator=(const atomic_flag &) /* = delete */ ;
uint32_t v_;
public:
- atomic_flag(void) : v_(0) {}
+ BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {}
bool
- test_and_set(memory_order order = memory_order_seq_cst) volatile
+ test_and_set(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
uint32_t v = 1;
atomics::detail::platform_fence_before(order);
@@ -167,7 +167,7 @@
}
void
- clear(memory_order order = memory_order_seq_cst) volatile
+ clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
if (order == memory_order_seq_cst) {
uint32_t v = 0;
@@ -246,16 +246,17 @@
namespace detail {
template<typename T, bool Sign>
-class base_atomic<T, int, 1, Sign> {
+class base_atomic<T, int, 1, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef T difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
if (order != memory_order_seq_cst) {
platform_fence_before(order);
@@ -266,7 +267,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v = const_cast<const volatile value_type &>(v_);
platform_fence_after_load(order);
@@ -274,7 +275,7 @@
}
value_type
- fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before(order);
__asm__ (
@@ -286,13 +287,13 @@
}
value_type
- fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before(order);
__asm__ (
@@ -308,7 +309,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
value_type previous = expected;
platform_fence_before(success_order);
@@ -331,13 +332,13 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ 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
+ fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type tmp = load(memory_order_relaxed);
for(; !compare_exchange_weak(tmp, tmp & v, order, memory_order_relaxed);)
@@ -348,7 +349,7 @@
}
value_type
- fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type tmp = load(memory_order_relaxed);
for (; !compare_exchange_weak(tmp, tmp | v, order, memory_order_relaxed);)
@@ -359,7 +360,7 @@
}
value_type
- fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type tmp = load(memory_order_relaxed);
for (; !compare_exchange_weak(tmp, tmp ^ v, order, memory_order_relaxed);)
@@ -370,7 +371,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -383,16 +384,17 @@
};
template<typename T, bool Sign>
-class base_atomic<T, int, 2, Sign> {
+class base_atomic<T, int, 2, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef T difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
if (order != memory_order_seq_cst) {
platform_fence_before(order);
@@ -403,7 +405,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v = const_cast<const volatile value_type &>(v_);
platform_fence_after_load(order);
@@ -411,7 +413,7 @@
}
value_type
- fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before(order);
__asm__ (
@@ -423,13 +425,13 @@
}
value_type
- fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before(order);
__asm__ (
@@ -445,7 +447,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
value_type previous = expected;
platform_fence_before(success_order);
@@ -468,13 +470,13 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ 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
+ fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type tmp = load(memory_order_relaxed);
for (; !compare_exchange_weak(tmp, tmp & v, order, memory_order_relaxed);)
@@ -485,7 +487,7 @@
}
value_type
- fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type tmp = load(memory_order_relaxed);
for (; !compare_exchange_weak(tmp, tmp | v, order, memory_order_relaxed);)
@@ -496,7 +498,7 @@
}
value_type
- fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type tmp = load(memory_order_relaxed);
for (; !compare_exchange_weak(tmp, tmp ^ v, order, memory_order_relaxed);)
@@ -507,7 +509,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -520,16 +522,17 @@
};
template<typename T, bool Sign>
-class base_atomic<T, int, 4, Sign> {
+class base_atomic<T, int, 4, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef T difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
if (order != memory_order_seq_cst) {
platform_fence_before(order);
@@ -540,7 +543,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v = const_cast<const volatile value_type &>(v_);
platform_fence_after_load(order);
@@ -548,7 +551,7 @@
}
value_type
- fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before(order);
__asm__ (
@@ -560,13 +563,13 @@
}
value_type
- fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before(order);
__asm__ (
@@ -582,7 +585,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
value_type previous = expected;
platform_fence_before(success_order);
@@ -605,13 +608,13 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ 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
+ fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type tmp = load(memory_order_relaxed);
for (; !compare_exchange_weak(tmp, tmp & v, order, memory_order_relaxed);)
@@ -622,7 +625,7 @@
}
value_type
- fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type tmp = load(memory_order_relaxed);
for (; !compare_exchange_weak(tmp, tmp | v, order, memory_order_relaxed);)
@@ -633,7 +636,7 @@
}
value_type
- fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type tmp = load(memory_order_relaxed);
for (; !compare_exchange_weak(tmp, tmp ^ v, order, memory_order_relaxed);)
@@ -644,7 +647,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -658,16 +661,17 @@
#if defined(__x86_64__)
template<typename T, bool Sign>
-class base_atomic<T, int, 8, Sign> {
+class base_atomic<T, int, 8, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef T difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
if (order != memory_order_seq_cst) {
platform_fence_before(order);
@@ -678,7 +682,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v = const_cast<const volatile value_type &>(v_);
platform_fence_after_load(order);
@@ -686,7 +690,7 @@
}
value_type
- fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before(order);
__asm__ (
@@ -698,13 +702,13 @@
}
value_type
- fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before(order);
__asm__ (
@@ -720,7 +724,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
value_type previous = expected;
platform_fence_before(success_order);
@@ -743,13 +747,13 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ 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
+ fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type tmp = load(memory_order_relaxed);
for (; !compare_exchange_weak(tmp, tmp & v, order, memory_order_relaxed);)
@@ -760,7 +764,7 @@
}
value_type
- fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type tmp = load(memory_order_relaxed);
for (; !compare_exchange_weak(tmp, tmp | v, order, memory_order_relaxed);)
@@ -771,7 +775,7 @@
}
value_type
- fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
value_type tmp = load(memory_order_relaxed);
for (; !compare_exchange_weak(tmp, tmp ^ v, order, memory_order_relaxed);)
@@ -782,7 +786,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -801,15 +805,16 @@
#if !defined(__x86_64__)
template<bool Sign>
-class base_atomic<void *, void *, 4, Sign> {
+class base_atomic<void *, void *, 4, Sign>
+{
typedef base_atomic this_type;
typedef void * value_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
if (order != memory_order_seq_cst) {
platform_fence_before(order);
@@ -819,14 +824,14 @@
}
}
- value_type load(memory_order order = memory_order_seq_cst) const volatile
+ value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v = const_cast<const volatile value_type &>(v_);
platform_fence_after_load(order);
return v;
}
- value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before(order);
__asm__ (
@@ -839,7 +844,7 @@
bool compare_exchange_strong(value_type & expected, value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
value_type previous = expected;
platform_fence_before(success_order);
@@ -859,13 +864,13 @@
bool compare_exchange_weak(value_type & expected, value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -878,16 +883,17 @@
};
template<typename T, bool Sign>
-class base_atomic<T *, void *, 4, Sign> {
+class base_atomic<T *, void *, 4, Sign>
+{
typedef base_atomic this_type;
typedef T * value_type;
typedef ptrdiff_t difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
if (order != memory_order_seq_cst) {
platform_fence_before(order);
@@ -898,7 +904,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v = const_cast<const volatile value_type &>(v_);
platform_fence_after_load(order);
@@ -906,7 +912,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before(order);
__asm__ (
@@ -922,7 +928,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
value_type previous = expected;
platform_fence_before(success_order);
@@ -945,13 +951,13 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ 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
+ fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
v = v * sizeof(*v_);
platform_fence_before(order);
@@ -964,13 +970,13 @@
}
value_type
- fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile
+ 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
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -985,15 +991,16 @@
#else
template<bool Sign>
-class base_atomic<void *, void *, 8, Sign> {
+class base_atomic<void *, void *, 8, Sign>
+{
typedef base_atomic this_type;
typedef void * value_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
if (order != memory_order_seq_cst) {
platform_fence_before(order);
@@ -1003,14 +1010,14 @@
}
}
- value_type load(memory_order order = memory_order_seq_cst) const volatile
+ value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v = const_cast<const volatile value_type &>(v_);
platform_fence_after_load(order);
return v;
}
- value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before(order);
__asm__ (
@@ -1023,7 +1030,7 @@
bool compare_exchange_strong(value_type & expected, value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
value_type previous = expected;
platform_fence_before(success_order);
@@ -1043,13 +1050,13 @@
bool compare_exchange_weak(value_type & expected, value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -1062,16 +1069,17 @@
};
template<typename T, bool Sign>
-class base_atomic<T *, void *, 8, Sign> {
+class base_atomic<T *, void *, 8, Sign>
+{
typedef base_atomic this_type;
typedef T * value_type;
typedef ptrdiff_t difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
if (order != memory_order_seq_cst) {
platform_fence_before(order);
@@ -1082,7 +1090,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v = const_cast<const volatile value_type &>(v_);
platform_fence_after_load(order);
@@ -1090,7 +1098,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before(order);
__asm__ (
@@ -1106,7 +1114,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
value_type previous = expected;
platform_fence_before(success_order);
@@ -1129,13 +1137,13 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ 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
+ fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
v = v * sizeof(*v_);
platform_fence_before(order);
@@ -1148,13 +1156,13 @@
}
value_type
- fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile
+ 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
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -1169,19 +1177,19 @@
#endif
template<typename T, bool Sign>
-class base_atomic<T, void, 1, Sign> {
+class base_atomic<T, void, 1, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef uint8_t storage_type;
public:
- explicit base_atomic(value_type const& v)
- {
- memcpy(&v_, &v, sizeof(value_type));
- }
+ BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT :
+ v_(reinterpret_cast<storage_type const&>(v))
+ {}
base_atomic(void) {}
void
- store(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
if (order != memory_order_seq_cst) {
storage_type tmp;
@@ -1194,7 +1202,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
storage_type tmp = const_cast<volatile storage_type &>(v_);
platform_fence_after_load(order);
@@ -1204,7 +1212,7 @@
}
value_type
- exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
storage_type tmp;
memcpy(&tmp, &v, sizeof(value_type));
@@ -1224,7 +1232,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
storage_type expected_s, desired_s;
memcpy(&expected_s, &expected, sizeof(value_type));
@@ -1250,13 +1258,13 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -1269,19 +1277,19 @@
};
template<typename T, bool Sign>
-class base_atomic<T, void, 2, Sign> {
+class base_atomic<T, void, 2, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef uint16_t storage_type;
public:
- explicit base_atomic(value_type const& v)
- {
- memcpy(&v_, &v, sizeof(value_type));
- }
+ BOOST_CONSTEXPR explicit base_atomic(value_type const& v) BOOST_NOEXCEPT :
+ v_(reinterpret_cast<storage_type const&>(v))
+ {}
base_atomic(void) {}
void
- store(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
if (order != memory_order_seq_cst) {
storage_type tmp;
@@ -1294,7 +1302,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
storage_type tmp = const_cast<volatile storage_type &>(v_);
platform_fence_after_load(order);
@@ -1304,7 +1312,7 @@
}
value_type
- exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
storage_type tmp;
memcpy(&tmp, &v, sizeof(value_type));
@@ -1324,7 +1332,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
storage_type expected_s, desired_s;
memcpy(&expected_s, &expected, sizeof(value_type));
@@ -1350,13 +1358,13 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -1369,19 +1377,20 @@
};
template<typename T, bool Sign>
-class base_atomic<T, void, 4, Sign> {
+class base_atomic<T, void, 4, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef uint32_t storage_type;
public:
- explicit base_atomic(value_type const& v) : v_(0)
+ explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
{
memcpy(&v_, &v, sizeof(value_type));
}
base_atomic(void) {}
void
- store(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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;
@@ -1394,7 +1403,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
storage_type tmp = const_cast<volatile storage_type &>(v_);
platform_fence_after_load(order);
@@ -1404,7 +1413,7 @@
}
value_type
- exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -1424,7 +1433,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
storage_type expected_s = 0, desired_s = 0;
memcpy(&expected_s, &expected, sizeof(value_type));
@@ -1450,13 +1459,13 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -1470,19 +1479,20 @@
#if defined(__x86_64__)
template<typename T, bool Sign>
-class base_atomic<T, void, 8, Sign> {
+class base_atomic<T, void, 8, Sign>
+{
typedef base_atomic this_type;
typedef T value_type;
typedef uint64_t storage_type;
public:
- explicit base_atomic(value_type const& v) : v_(0)
+ explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : v_(0)
{
memcpy(&v_, &v, sizeof(value_type));
}
base_atomic(void) {}
void
- store(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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;
@@ -1495,7 +1505,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
storage_type tmp = const_cast<volatile storage_type &>(v_);
platform_fence_after_load(order);
@@ -1505,7 +1515,7 @@
}
value_type
- exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -1525,7 +1535,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
storage_type expected_s = 0, desired_s = 0;
memcpy(&expected_s, &expected, sizeof(value_type));
@@ -1551,13 +1561,13 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -1625,7 +1635,7 @@
template<typename T>
inline T
-platform_load64(const volatile T * ptr)
+platform_load64(const volatile T * ptr) BOOST_NOEXCEPT
{
T expected = *ptr;
for (; !platform_cmpxchg64_strong(expected, expected, const_cast<volatile T*>(ptr));)
Modified: branches/release/boost/atomic/detail/generic-cas.hpp
==============================================================================
--- branches/release/boost/atomic/detail/generic-cas.hpp (original)
+++ branches/release/boost/atomic/detail/generic-cas.hpp 2013-03-23 13:50:41 EDT (Sat, 23 Mar 2013)
@@ -118,7 +118,8 @@
#ifdef BOOST_ATOMIC_HAVE_CAS32
template<typename T>
-class atomic_generic_cas32 {
+class atomic_generic_cas32
+{
private:
typedef atomic_generic_cas32 this_type;
public:
@@ -168,7 +169,9 @@
};
template<typename T>
-class platform_atomic_integral<T, 4> : public build_atomic_from_exchange<atomic_generic_cas32<T> > {
+class platform_atomic_integral<T, 4> :
+ public build_atomic_from_exchange<atomic_generic_cas32<T> >
+{
public:
typedef build_atomic_from_exchange<atomic_generic_cas32<T> > super;
explicit platform_atomic_integral(T v) : super(v) {}
@@ -176,7 +179,9 @@
};
template<typename T>
-class platform_atomic_integral<T, 1>: public build_atomic_from_larger_type<atomic_generic_cas32<int32_t>, T> {
+class platform_atomic_integral<T, 1> :
+ public build_atomic_from_larger_type<atomic_generic_cas32<int32_t>, T>
+{
public:
typedef build_atomic_from_larger_type<atomic_generic_cas32<int32_t>, T> super;
@@ -185,7 +190,9 @@
};
template<typename T>
-class platform_atomic_integral<T, 2>: public build_atomic_from_larger_type<atomic_generic_cas32<int32_t>, T> {
+class platform_atomic_integral<T, 2> :
+ public build_atomic_from_larger_type<atomic_generic_cas32<int32_t>, T>
+{
public:
typedef build_atomic_from_larger_type<atomic_generic_cas32<int32_t>, T> super;
Modified: branches/release/boost/atomic/detail/interlocked.hpp
==============================================================================
--- branches/release/boost/atomic/detail/interlocked.hpp (original)
+++ branches/release/boost/atomic/detail/interlocked.hpp 2013-03-23 13:50:41 EDT (Sat, 23 Mar 2013)
@@ -2,7 +2,7 @@
#define BOOST_ATOMIC_DETAIL_INTERLOCKED_HPP
// Copyright (c) 2009 Helge Bahmann
-// Copyright (c) 2012 Andrey Semashev
+// Copyright (c) 2012, 2013 Andrey Semashev
//
// Distributed under the Boost Software License, Version 1.0.
// See accompanying file LICENSE_1_0.txt or copy at
@@ -14,7 +14,7 @@
#pragma once
#endif
-#if defined(_WIN32_WCE)
+#if defined(_WIN32_WCE) || (defined(_MSC_VER) && _MSC_VER < 1400)
#include <boost/detail/interlocked.hpp>
@@ -25,30 +25,24 @@
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(dest, newval) BOOST_INTERLOCKED_EXCHANGE_POINTER(dest, newval)
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER(dest, byte_offset) ((void*)BOOST_INTERLOCKED_EXCHANGE_ADD((long*)(dest), byte_offset))
-#elif defined(_MSC_VER)
+#elif defined(_MSC_VER) && _MSC_VER >= 1400
#include <intrin.h>
#pragma intrinsic(_InterlockedCompareExchange)
#pragma intrinsic(_InterlockedExchangeAdd)
#pragma intrinsic(_InterlockedExchange)
-
-#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(dest, exchange, compare) _InterlockedCompareExchange((long*)(dest), (long)(exchange), (long)(compare))
-#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(dest, addend) _InterlockedExchangeAdd((long*)(dest), (long)(addend))
-#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE(dest, newval) _InterlockedExchange((long*)(dest), (long)(newval))
-
-#if _MSC_VER >= 1400
-
#pragma intrinsic(_InterlockedAnd)
#pragma intrinsic(_InterlockedOr)
#pragma intrinsic(_InterlockedXor)
+#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(dest, exchange, compare) _InterlockedCompareExchange((long*)(dest), (long)(exchange), (long)(compare))
+#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(dest, addend) _InterlockedExchangeAdd((long*)(dest), (long)(addend))
+#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE(dest, newval) _InterlockedExchange((long*)(dest), (long)(newval))
#define BOOST_ATOMIC_INTERLOCKED_AND(dest, arg) _InterlockedAnd((long*)(dest), (long)(arg))
#define BOOST_ATOMIC_INTERLOCKED_OR(dest, arg) _InterlockedOr((long*)(dest), (long)(arg))
#define BOOST_ATOMIC_INTERLOCKED_XOR(dest, arg) _InterlockedXor((long*)(dest), (long)(arg))
-#endif // _MSC_VER >= 1400
-
#if _MSC_VER >= 1600
// MSVC 2010 and later provide intrinsics for 8 and 16 bit integers.
@@ -108,15 +102,15 @@
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(dest, newval) _InterlockedExchangePointer((void**)(dest), (void*)(newval))
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER(dest, byte_offset) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64((long*)(dest), byte_offset))
-#else // defined(_M_AMD64)
+#else // defined(_M_AMD64) || defined(_M_IA64)
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) ((void*)_InterlockedCompareExchange((long*)(dest), (long)(exchange), (long)(compare)))
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(dest, newval) ((void*)_InterlockedExchange((long*)(dest), (long)(newval)))
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER(dest, byte_offset) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD((long*)(dest), byte_offset))
-#endif // defined(_M_AMD64)
+#endif // defined(_M_AMD64) || defined(_M_IA64)
-#else // defined(_MSC_VER)
+#else // defined(_MSC_VER) && _MSC_VER >= 1400
#if defined(BOOST_USE_WINDOWS_H)
Modified: branches/release/boost/atomic/detail/linux-arm.hpp
==============================================================================
--- branches/release/boost/atomic/detail/linux-arm.hpp (original)
+++ branches/release/boost/atomic/detail/linux-arm.hpp 2013-03-23 13:50:41 EDT (Sat, 23 Mar 2013)
@@ -7,6 +7,7 @@
//
// 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,
@@ -132,16 +133,17 @@
__asm__ __volatile__ ("" ::: "memory");
}
-class atomic_flag {
+class atomic_flag
+{
private:
atomic_flag(const atomic_flag &) /* = delete */ ;
atomic_flag & operator=(const atomic_flag &) /* = delete */ ;
uint32_t v_;
public:
- atomic_flag(void) : v_(false) {}
+ BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {}
void
- clear(memory_order order = memory_order_seq_cst) volatile
+ clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
atomics::detail::platform_fence_before_store(order);
const_cast<volatile uint32_t &>(v_) = 0;
@@ -149,7 +151,7 @@
}
bool
- test_and_set(memory_order order = memory_order_seq_cst) volatile
+ test_and_set(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
atomics::detail::platform_fence_before(order);
uint32_t expected = v_;
Modified: branches/release/boost/atomic/detail/windows.hpp
==============================================================================
--- branches/release/boost/atomic/detail/windows.hpp (original)
+++ branches/release/boost/atomic/detail/windows.hpp 2013-03-23 13:50:41 EDT (Sat, 23 Mar 2013)
@@ -3,6 +3,7 @@
// 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
@@ -24,10 +25,6 @@
#pragma warning(disable: 4100)
#endif
-namespace boost {
-namespace atomics {
-namespace detail {
-
#if defined(_MSC_VER) && (defined(_M_AMD64) || defined(_M_IX86))
extern "C" void _mm_pause(void);
#pragma intrinsic(_mm_pause)
@@ -42,6 +39,23 @@
#pragma intrinsic(_mm_mfence)
#endif
+// Define compiler barriers
+#if defined(__INTEL_COMPILER)
+#define BOOST_ATOMIC_COMPILER_BARRIER __memory_barrier();
+#elif defined(_MSC_VER) && _MSC_VER >= 1310 && !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)
{
#if defined(_MSC_VER) && (defined(_M_AMD64) || (defined(_M_IX86) && defined(_M_IX86_FP) && _M_IX86_FP >= 2))
@@ -57,41 +71,41 @@
#if defined(_MSC_VER) && _MSC_VER >= 1310 && !defined(_WIN32_WCE)
extern "C" void _ReadWriteBarrier();
#pragma intrinsic(_ReadWriteBarrier)
-#define BOOST_ATOMIC_READ_WRITE_BARRIER() _ReadWriteBarrier()
+#define BOOST_ATOMIC_COMPILER_BARRIER() _ReadWriteBarrier()
#endif
-#ifndef BOOST_ATOMIC_READ_WRITE_BARRIER
-#define BOOST_ATOMIC_READ_WRITE_BARRIER()
+#ifndef BOOST_ATOMIC_COMPILER_BARRIER
+#define BOOST_ATOMIC_COMPILER_BARRIER()
#endif
BOOST_FORCEINLINE void
platform_fence_before(memory_order)
{
- BOOST_ATOMIC_READ_WRITE_BARRIER();
+ BOOST_ATOMIC_COMPILER_BARRIER();
}
BOOST_FORCEINLINE void
platform_fence_after(memory_order)
{
- BOOST_ATOMIC_READ_WRITE_BARRIER();
+ BOOST_ATOMIC_COMPILER_BARRIER();
}
BOOST_FORCEINLINE void
platform_fence_before_store(memory_order)
{
- BOOST_ATOMIC_READ_WRITE_BARRIER();
+ BOOST_ATOMIC_COMPILER_BARRIER();
}
BOOST_FORCEINLINE void
platform_fence_after_store(memory_order)
{
- BOOST_ATOMIC_READ_WRITE_BARRIER();
+ BOOST_ATOMIC_COMPILER_BARRIER();
}
BOOST_FORCEINLINE void
platform_fence_after_load(memory_order order)
{
- BOOST_ATOMIC_READ_WRITE_BARRIER();
+ 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
@@ -112,7 +126,7 @@
BOOST_FORCEINLINE void
atomic_thread_fence(memory_order order)
{
- BOOST_ATOMIC_READ_WRITE_BARRIER();
+ BOOST_ATOMIC_COMPILER_BARRIER();
if (order == memory_order_seq_cst)
atomics::detail::hardware_full_fence();
}
@@ -121,10 +135,10 @@
BOOST_FORCEINLINE void
atomic_signal_fence(memory_order)
{
- BOOST_ATOMIC_READ_WRITE_BARRIER();
+ BOOST_ATOMIC_COMPILER_BARRIER();
}
-#undef BOOST_ATOMIC_READ_WRITE_BARRIER
+#undef BOOST_ATOMIC_COMPILER_BARRIER
class atomic_flag
{
@@ -133,10 +147,10 @@
atomic_flag & operator=(const atomic_flag &) /* = delete */ ;
uint32_t v_;
public:
- atomic_flag(void) : v_(0) {}
+ BOOST_CONSTEXPR atomic_flag(void) BOOST_NOEXCEPT : v_(0) {}
bool
- test_and_set(memory_order order = memory_order_seq_cst) volatile
+ test_and_set(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
atomics::detail::platform_fence_before(order);
const uint32_t old = (uint32_t)BOOST_ATOMIC_INTERLOCKED_EXCHANGE(&v_, 1);
@@ -145,7 +159,7 @@
}
void
- clear(memory_order order = memory_order_seq_cst) volatile
+ clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
atomics::detail::platform_fence_before_store(order);
BOOST_ATOMIC_INTERLOCKED_EXCHANGE(&v_, 0);
@@ -195,11 +209,11 @@
#endif
typedef T difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
if (order != memory_order_seq_cst) {
platform_fence_before(order);
@@ -210,7 +224,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v = static_cast< value_type >(v_);
platform_fence_after_load(order);
@@ -218,7 +232,7 @@
}
value_type
- fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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
@@ -231,14 +245,14 @@
}
value_type
- fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before(order);
#ifdef BOOST_ATOMIC_INTERLOCKED_EXCHANGE8
@@ -255,7 +269,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
value_type previous = expected;
platform_fence_before(success_order);
@@ -278,13 +292,13 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ 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
+ fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
#ifdef BOOST_ATOMIC_INTERLOCKED_AND8
platform_fence_before(order);
@@ -307,7 +321,7 @@
}
value_type
- fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
#ifdef BOOST_ATOMIC_INTERLOCKED_OR8
platform_fence_before(order);
@@ -330,7 +344,7 @@
}
value_type
- fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
#ifdef BOOST_ATOMIC_INTERLOCKED_XOR8
platform_fence_before(order);
@@ -353,7 +367,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -381,11 +395,11 @@
#endif
typedef T difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
if (order != memory_order_seq_cst) {
platform_fence_before(order);
@@ -396,7 +410,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v = static_cast< value_type >(v_);
platform_fence_after_load(order);
@@ -404,7 +418,7 @@
}
value_type
- fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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
@@ -417,14 +431,14 @@
}
value_type
- fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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
+ exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
platform_fence_before(order);
#ifdef BOOST_ATOMIC_INTERLOCKED_EXCHANGE16
@@ -441,7 +455,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
value_type previous = expected;
platform_fence_before(success_order);
@@ -464,13 +478,13 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ 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
+ fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
#ifdef BOOST_ATOMIC_INTERLOCKED_AND16
platform_fence_before(order);
@@ -493,7 +507,7 @@
}
value_type
- fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
#ifdef BOOST_ATOMIC_INTERLOCKED_OR16
platform_fence_before(order);
@@ -516,7 +530,7 @@
}
value_type
- fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile
+ fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
#ifdef BOOST_ATOMIC_INTERLOCKED_XOR16
platform_fence_before(order);
@@ -539,7 +553,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -559,11 +573,11 @@
typedef value_type storage_type;
typedef T difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
if (order != memory_order_seq_cst) {
platform_fence_before(order);
@@ -574,7 +588,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
value_type v = static_cast< value_type >(v_);
platform_fence_after_load(order);
@@ -582,7 +596,7 @@
}
value_type
- fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -591,14 +605,14 @@
}
value_type
- fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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
+ 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));
@@ -611,7 +625,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
value_type previous = expected;
platform_fence_before(success_order);
@@ -630,13 +644,13 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ 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
+ 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);
@@ -654,7 +668,7 @@
}
value_type
- fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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);
@@ -672,7 +686,7 @@
}
value_type
- fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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);
@@ -690,7 +704,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void)const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -712,11 +726,11 @@
typedef value_type storage_type;
typedef T difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
if (order != memory_order_seq_cst) {
platform_fence_before(order);
@@ -727,7 +741,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst)const volatile BOOST_NOEXCEPT
{
value_type v = static_cast< value_type >(v_);
platform_fence_after_load(order);
@@ -735,7 +749,7 @@
}
value_type
- fetch_add(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -744,14 +758,14 @@
}
value_type
- fetch_sub(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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
+ 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));
@@ -764,7 +778,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
value_type previous = expected;
platform_fence_before(success_order);
@@ -783,13 +797,13 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ 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
+ 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);
@@ -807,7 +821,7 @@
}
value_type
- fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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);
@@ -825,7 +839,7 @@
}
value_type
- fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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);
@@ -843,7 +857,7 @@
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void)const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -866,11 +880,11 @@
typedef base_atomic this_type;
typedef void* value_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
if (order != memory_order_seq_cst) {
platform_fence_before(order);
@@ -880,14 +894,14 @@
}
}
- value_type load(memory_order order = memory_order_seq_cst) const volatile
+ value_type load(memory_order order = memory_order_seq_cst)const volatile BOOST_NOEXCEPT
{
value_type v = const_cast<const volatile value_type &>(v_);
platform_fence_after_load(order);
return v;
}
- value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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);
@@ -897,7 +911,7 @@
bool compare_exchange_strong(value_type & expected, value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
value_type previous = expected;
platform_fence_before(success_order);
@@ -913,13 +927,13 @@
bool compare_exchange_weak(value_type & expected, value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void)const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -938,11 +952,11 @@
typedef T* value_type;
typedef ptrdiff_t difference_type;
public:
- explicit base_atomic(value_type v) : v_(v) {}
+ BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
base_atomic(void) {}
void
- store(value_type v, memory_order order = memory_order_seq_cst) volatile
+ store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
if (order != memory_order_seq_cst) {
platform_fence_before(order);
@@ -953,7 +967,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst)const volatile BOOST_NOEXCEPT
{
value_type v = const_cast<const volatile value_type &>(v_);
platform_fence_after_load(order);
@@ -961,7 +975,7 @@
}
value_type
- exchange(value_type v, memory_order order = memory_order_seq_cst) volatile
+ 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);
@@ -974,7 +988,7 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
value_type previous = expected;
platform_fence_before(success_order);
@@ -993,13 +1007,13 @@
value_type & expected,
value_type desired,
memory_order success_order,
- memory_order failure_order) volatile
+ 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
+ fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
v = v * sizeof(*v_);
platform_fence_before(order);
@@ -1009,13 +1023,13 @@
}
value_type
- fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile
+ 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
+ is_lock_free(void)const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -1039,14 +1053,20 @@
typedef uint32_t storage_type;
#endif
public:
- explicit base_atomic(value_type const& v) : v_(0)
+#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
base_atomic(void) {}
void
- store(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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;
@@ -1059,7 +1079,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
storage_type tmp = const_cast<volatile storage_type &>(v_);
platform_fence_after_load(order);
@@ -1069,7 +1089,7 @@
}
value_type
- exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -1090,7 +1110,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
storage_type expected_s = 0, desired_s = 0;
memcpy(&expected_s, &expected, sizeof(value_type));
@@ -1115,13 +1135,13 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void) const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -1144,14 +1164,21 @@
typedef uint32_t storage_type;
#endif
public:
- explicit base_atomic(value_type const& v) : v_(0)
+#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
+
base_atomic(void) {}
void
- store(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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;
@@ -1164,7 +1191,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst)const volatile BOOST_NOEXCEPT
{
storage_type tmp = const_cast<volatile storage_type &>(v_);
platform_fence_after_load(order);
@@ -1174,7 +1201,7 @@
}
value_type
- exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -1195,7 +1222,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
storage_type expected_s = 0, desired_s = 0;
memcpy(&expected_s, &expected, sizeof(value_type));
@@ -1220,13 +1247,13 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void)const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -1252,7 +1279,7 @@
base_atomic(void) {}
void
- store(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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;
@@ -1265,7 +1292,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst)const volatile BOOST_NOEXCEPT
{
storage_type tmp = const_cast<volatile storage_type &>(v_);
platform_fence_after_load(order);
@@ -1275,7 +1302,7 @@
}
value_type
- exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -1292,7 +1319,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
storage_type expected_s = 0, desired_s = 0;
memcpy(&expected_s, &expected, sizeof(value_type));
@@ -1313,13 +1340,13 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void)const volatile BOOST_NOEXCEPT
{
return true;
}
@@ -1347,7 +1374,7 @@
base_atomic(void) {}
void
- store(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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;
@@ -1360,7 +1387,7 @@
}
value_type
- load(memory_order order = memory_order_seq_cst) const volatile
+ load(memory_order order = memory_order_seq_cst)const volatile BOOST_NOEXCEPT
{
storage_type tmp = const_cast<volatile storage_type &>(v_);
platform_fence_after_load(order);
@@ -1370,7 +1397,7 @@
}
value_type
- exchange(value_type const& v, memory_order order = memory_order_seq_cst) volatile
+ 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));
@@ -1387,7 +1414,7 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
storage_type expected_s = 0, desired_s = 0;
memcpy(&expected_s, &expected, sizeof(value_type));
@@ -1408,13 +1435,13 @@
value_type & expected,
value_type const& desired,
memory_order success_order,
- memory_order failure_order) volatile
+ memory_order failure_order) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, success_order, failure_order);
}
bool
- is_lock_free(void) const volatile
+ is_lock_free(void)const volatile BOOST_NOEXCEPT
{
return true;
}
Modified: branches/release/libs/atomic/test/api_test_helpers.hpp
==============================================================================
--- branches/release/libs/atomic/test/api_test_helpers.hpp (original)
+++ branches/release/libs/atomic/test/api_test_helpers.hpp 2013-03-23 13:50:41 EDT (Sat, 23 Mar 2013)
@@ -100,6 +100,17 @@
}
}
+// T requires an int constructor
+template <typename T>
+void test_constexpr_ctor()
+{
+#ifndef BOOST_NO_CXX11_CONSTEXPR
+ const T value(0);
+ const boost::atomic<T> tester(value);
+ BOOST_CHECK( tester == value );
+#endif
+}
+
template<typename T, typename D>
void test_additive_operators(T value, D delta)
{
Modified: branches/release/libs/atomic/test/native_api.cpp
==============================================================================
--- branches/release/libs/atomic/test/native_api.cpp (original)
+++ branches/release/libs/atomic/test/native_api.cpp 2013-03-23 13:50:41 EDT (Sat, 23 Mar 2013)
@@ -34,6 +34,12 @@
test_integral_api<long long>();
test_integral_api<unsigned long long>();
+ test_constexpr_ctor<char>();
+ test_constexpr_ctor<short>();
+ test_constexpr_ctor<int>();
+ test_constexpr_ctor<long>();
+ test_constexpr_ctor<int*>();
+
test_pointer_api<int>();
test_enum_api();
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk