[Boost-commit] svn:boost r84190 - in trunk: boost/atomic/detail libs/atomic/test

Subject: [Boost-commit] svn:boost r84190 - in trunk: boost/atomic/detail libs/atomic/test
From: tim_at_[hidden]
Date: 2013-05-08 00:45:40

Author: timblechmann
Date: 2013-05-08 00:45:38 EDT (Wed, 08 May 2013)
New Revision: 84190
URL: http://svn.boost.org/trac/boost/changeset/84190

Log:
atomic: provide additive functionality for atomic<void*>

fixes #8501
Text files modified: 
   trunk/boost/atomic/detail/base.hpp          |    67 +++++++++++++++++++++++++++++++++       
   trunk/boost/atomic/detail/cas32strong.hpp   |     6 +-                                      
   trunk/boost/atomic/detail/cas32weak.hpp     |    20 +++++++++                               
   trunk/boost/atomic/detail/cas64strong.hpp   |     6 +-                                      
   trunk/boost/atomic/detail/gcc-ppc.hpp       |    78 ++++++++++++++++++++++++++++++++++++++- 
   trunk/boost/atomic/detail/gcc-sparcv9.hpp   |    20 +++++++++                               
   trunk/boost/atomic/detail/gcc-x86.hpp       |    42 ++++++++++++++++++++-                   
   trunk/boost/atomic/detail/windows.hpp       |    18 ++++++++                                
   trunk/libs/atomic/test/api_test_helpers.hpp |    35 ++++++++++-------                       
   9 files changed, 264 insertions(+), 28 deletions(-)

Modified: trunk/boost/atomic/detail/base.hpp
==============================================================================
--- trunk/boost/atomic/detail/base.hpp	(original)
+++ trunk/boost/atomic/detail/base.hpp	2013-05-08 00:45:38 EDT (Wed, 08 May 2013)
@@ -79,6 +79,43 @@
         return fetch_sub(v) - v; \
     } \
 
+#define BOOST_ATOMIC_DECLARE_VOID_POINTER_ADDITIVE_OPERATORS \
+    value_type \
+    operator++(int) volatile BOOST_NOEXCEPT \
+    { \
+        return fetch_add(1); \
+    } \
+     \
+    value_type \
+    operator++(void) volatile BOOST_NOEXCEPT \
+    { \
+        return (char*)fetch_add(1) + 1;         \
+    } \
+     \
+    value_type \
+    operator--(int) volatile BOOST_NOEXCEPT \
+    { \
+        return fetch_sub(1); \
+    } \
+     \
+    value_type \
+    operator--(void) volatile BOOST_NOEXCEPT \
+    { \
+        return (char*)fetch_sub(1) - 1;         \
+    } \
+     \
+    value_type \
+    operator+=(difference_type v) volatile BOOST_NOEXCEPT \
+    { \
+        return (char*)fetch_add(v) + v; \
+    } \
+     \
+    value_type \
+    operator-=(difference_type v) volatile BOOST_NOEXCEPT \
+    { \
+        return (char*)fetch_sub(v) - v; \
+    } \
+
 #define BOOST_ATOMIC_DECLARE_BIT_OPERATORS \
     value_type \
     operator&=(difference_type v) volatile BOOST_NOEXCEPT \
@@ -102,6 +139,10 @@
     BOOST_ATOMIC_DECLARE_BASE_OPERATORS \
     BOOST_ATOMIC_DECLARE_ADDITIVE_OPERATORS \
 
+#define BOOST_ATOMIC_DECLARE_VOID_POINTER_OPERATORS \
+    BOOST_ATOMIC_DECLARE_BASE_OPERATORS \
+    BOOST_ATOMIC_DECLARE_VOID_POINTER_ADDITIVE_OPERATORS \
+
 #define BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS \
     BOOST_ATOMIC_DECLARE_BASE_OPERATORS \
     BOOST_ATOMIC_DECLARE_ADDITIVE_OPERATORS \
@@ -444,6 +485,7 @@
 {
 private:
     typedef base_atomic this_type;
+    typedef ptrdiff_t difference_type;
     typedef void * value_type;
     typedef lockpool::scoped_lock guard_type;
 public:
@@ -506,7 +548,30 @@
         return false;
     }
 
-    BOOST_ATOMIC_DECLARE_BASE_OPERATORS
+    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_));
+
+        value_type old = v_;
+        char * cv = reinterpret_cast<char*>(old);
+        cv += v;
+        v_ = cv;
+        return old;
+    }
+
+    value_type fetch_sub(difference_type v, memory_order /*order*/ = memory_order_seq_cst) volatile
+    {
+        guard_type guard(const_cast<value_type *>(&v_));
+
+        value_type old = v_;
+        char * cv = reinterpret_cast<char*>(old);
+        cv -= v;
+        v_ = cv;
+        return old;
+    }
+
+    BOOST_ATOMIC_DECLARE_VOID_POINTER_OPERATORS
+
 private:
     base_atomic(const base_atomic &) /* = delete */ ;
     void operator=(const base_atomic &) /* = delete */ ;

Modified: trunk/boost/atomic/detail/cas32strong.hpp
==============================================================================
--- trunk/boost/atomic/detail/cas32strong.hpp	(original)
+++ trunk/boost/atomic/detail/cas32strong.hpp	2013-05-08 00:45:38 EDT (Wed, 08 May 2013)
@@ -479,7 +479,7 @@
     {
         value_type original = load(memory_order_relaxed);
         do {
-        } while (!compare_exchange_weak(original, original + v, order, memory_order_relaxed));
+        } while (!compare_exchange_weak(original, (char*)original + v, order, memory_order_relaxed));
         return original;
     }
 
@@ -488,7 +488,7 @@
     {
         value_type original = load(memory_order_relaxed);
         do {
-        } while (!compare_exchange_weak(original, original - v, order, memory_order_relaxed));
+        } while (!compare_exchange_weak(original, (char*)original - v, order, memory_order_relaxed));
         return original;
     }
 
@@ -498,7 +498,7 @@
         return true;
     }
 
-    BOOST_ATOMIC_DECLARE_BASE_OPERATORS
+    BOOST_ATOMIC_DECLARE_VOID_POINTER_OPERATORS
 private:
     base_atomic(const base_atomic &) /* = delete */ ;
     void operator=(const base_atomic &) /* = delete */ ;

Modified: trunk/boost/atomic/detail/cas32weak.hpp
==============================================================================
--- trunk/boost/atomic/detail/cas32weak.hpp	(original)
+++ trunk/boost/atomic/detail/cas32weak.hpp	2013-05-08 00:45:38 EDT (Wed, 08 May 2013)
@@ -509,7 +509,25 @@
         return true;
     }
 
-    BOOST_ATOMIC_DECLARE_BASE_OPERATORS
+    value_type
+    fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    {
+        value_type original = load(memory_order_relaxed);
+        do {
+        } while (!compare_exchange_weak(original, (char*)original + v, order, memory_order_relaxed));
+        return original;
+    }
+
+    value_type
+    fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    {
+        value_type original = load(memory_order_relaxed);
+        do {
+        } while (!compare_exchange_weak(original, (char*)original - v, order, memory_order_relaxed));
+        return original;
+    }
+
+    BOOST_ATOMIC_DECLARE_VOID_POINTER_OPERATORS
 private:
     base_atomic(const base_atomic &) /* = delete */ ;
     void operator=(const base_atomic &) /* = delete */ ;

Modified: trunk/boost/atomic/detail/cas64strong.hpp
==============================================================================
--- trunk/boost/atomic/detail/cas64strong.hpp	(original)
+++ trunk/boost/atomic/detail/cas64strong.hpp	2013-05-08 00:45:38 EDT (Wed, 08 May 2013)
@@ -223,7 +223,7 @@
     {
         value_type original = load(memory_order_relaxed);
         do {
-        } while (!compare_exchange_weak(original, original + v, order, memory_order_relaxed));
+        } while (!compare_exchange_weak(original, (char*)original + v, order, memory_order_relaxed));
         return original;
     }
 
@@ -232,7 +232,7 @@
     {
         value_type original = load(memory_order_relaxed);
         do {
-        } while (!compare_exchange_weak(original, original - v, order, memory_order_relaxed));
+        } while (!compare_exchange_weak(original, (char*)original - v, order, memory_order_relaxed));
         return original;
     }
 
@@ -242,7 +242,7 @@
         return true;
     }
 
-    BOOST_ATOMIC_DECLARE_BASE_OPERATORS
+    BOOST_ATOMIC_DECLARE_VOID_POINTER_OPERATORS
 private:
     base_atomic(const base_atomic &) /* = delete */ ;
     void operator=(const base_atomic &) /* = delete */ ;

Modified: trunk/boost/atomic/detail/gcc-ppc.hpp
==============================================================================
--- trunk/boost/atomic/detail/gcc-ppc.hpp	(original)
+++ trunk/boost/atomic/detail/gcc-ppc.hpp	2013-05-08 00:45:38 EDT (Wed, 08 May 2013)
@@ -1525,6 +1525,7 @@
 class base_atomic<void *, void *, 4, Sign>
 {
     typedef base_atomic this_type;
+    typedef ptrdiff_t difference_type;
     typedef void * value_type;
 public:
     BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
@@ -1643,7 +1644,43 @@
         return true;
     }
 
-    BOOST_ATOMIC_DECLARE_BASE_OPERATORS
+    value_type
+    fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    {
+        value_type original, tmp;
+        ppc_fence_before(order);
+        __asm__ (
+            "1:\n"
+            "lwarx %0,%y2\n"
+            "add %1,%0,%3\n"
+            "stwcx. %1,%y2\n"
+            "bne- 1b\n"
+            : "=&b" (original), "=&b" (tmp), "+Z"(v_)
+            : "b" (v)
+            : "cc");
+        ppc_fence_after(order);
+        return original;
+    }
+
+    value_type
+    fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    {
+        value_type original, tmp;
+        ppc_fence_before(order);
+        __asm__ (
+            "1:\n"
+            "lwarx %0,%y2\n"
+            "sub %1,%0,%3\n"
+            "stwcx. %1,%y2\n"
+            "bne- 1b\n"
+            : "=&b" (original), "=&b" (tmp), "+Z"(v_)
+            : "b" (v)
+            : "cc");
+        ppc_fence_after(order);
+        return original;
+    }
+
+    BOOST_ATOMIC_DECLARE_VOID_POINTER_OPERATORS
 private:
     base_atomic(const base_atomic &) /* = delete */ ;
     void operator=(const base_atomic &) /* = delete */ ;
@@ -1824,6 +1861,7 @@
 class base_atomic<void *, void *, 8, Sign>
 {
     typedef base_atomic this_type;
+    typedef ptrdiff_t difference_type;
     typedef void * value_type;
 public:
     BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
@@ -1942,7 +1980,43 @@
         return true;
     }
 
-    BOOST_ATOMIC_DECLARE_BASE_OPERATORS
+    value_type
+    fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    {
+        value_type original, tmp;
+        ppc_fence_before(order);
+        __asm__ (
+            "1:\n"
+            "ldarx %0,%y2\n"
+            "add %1,%0,%3\n"
+            "stdcx. %1,%y2\n"
+            "bne- 1b\n"
+            : "=&b" (original), "=&b" (tmp), "+Z"(v_)
+            : "b" (v)
+            : "cc");
+        ppc_fence_after(order);
+        return original;
+    }
+
+    value_type
+    fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    {
+        value_type original, tmp;
+        ppc_fence_before(order);
+        __asm__ (
+            "1:\n"
+            "ldarx %0,%y2\n"
+            "sub %1,%0,%3\n"
+            "stdcx. %1,%y2\n"
+            "bne- 1b\n"
+            : "=&b" (original), "=&b" (tmp), "+Z"(v_)
+            : "b" (v)
+            : "cc");
+        ppc_fence_after(order);
+        return original;
+    }
+
+    BOOST_ATOMIC_DECLARE_VOID_POINTER_OPERATORS
 private:
     base_atomic(const base_atomic &) /* = delete */ ;
     void operator=(const base_atomic &) /* = delete */ ;

Modified: trunk/boost/atomic/detail/gcc-sparcv9.hpp
==============================================================================
--- trunk/boost/atomic/detail/gcc-sparcv9.hpp	(original)
+++ trunk/boost/atomic/detail/gcc-sparcv9.hpp	2013-05-08 00:45:38 EDT (Wed, 08 May 2013)
@@ -792,6 +792,7 @@
 class base_atomic<void *, void *, 4, Sign>
 {
     typedef base_atomic this_type;
+    typedef ptrdiff_t difference_type;
     typedef void * value_type;
 public:
     BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
@@ -857,7 +858,24 @@
         return true;
     }
 
-    BOOST_ATOMIC_DECLARE_BASE_OPERATORS
+    value_type
+    fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    {
+        value_type tmp = load(memory_order_relaxed);
+        do {} while(!compare_exchange_weak(tmp, (char*)tmp + v, order, memory_order_relaxed));
+        return tmp;
+    }
+
+    value_type
+    fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    {
+        value_type tmp = load(memory_order_relaxed);
+        do {} while(!compare_exchange_weak(tmp, (char*)tmp - v, order, memory_order_relaxed));
+        return tmp;
+    }
+
+    BOOST_ATOMIC_DECLARE_VOID_POINTER_OPERATORS
+
 private:
     base_atomic(const base_atomic &) /* = delete */ ;
     void operator=(const base_atomic &) /* = delete */ ;

Modified: trunk/boost/atomic/detail/gcc-x86.hpp
==============================================================================
--- trunk/boost/atomic/detail/gcc-x86.hpp	(original)
+++ trunk/boost/atomic/detail/gcc-x86.hpp	2013-05-08 00:45:38 EDT (Wed, 08 May 2013)
@@ -808,6 +808,7 @@
 class base_atomic<void *, void *, 4, Sign>
 {
     typedef base_atomic this_type;
+    typedef ptrdiff_t difference_type;
     typedef void * value_type;
 public:
     BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
@@ -875,7 +876,25 @@
         return true;
     }
 
-    BOOST_ATOMIC_DECLARE_BASE_OPERATORS
+    value_type
+    fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    {
+        platform_fence_before(order);
+        __asm__ (
+        "lock ; xaddl %0, %1"
+        : "+r" (v), "+m" (v_)
+                );
+        platform_fence_after(order);
+        return reinterpret_cast<value_type>(v);
+    }
+
+    value_type
+    fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    {
+        return fetch_add(-v, order);
+    }
+
+    BOOST_ATOMIC_DECLARE_VOID_POINTER_OPERATORS
 private:
     base_atomic(const base_atomic &) /* = delete */ ;
     void operator=(const base_atomic &) /* = delete */ ;
@@ -994,6 +1013,7 @@
 class base_atomic<void *, void *, 8, Sign>
 {
     typedef base_atomic this_type;
+    typedef ptrdiff_t difference_type;
     typedef void * value_type;
 public:
     BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : v_(v) {}
@@ -1061,7 +1081,25 @@
         return true;
     }
 
-    BOOST_ATOMIC_DECLARE_BASE_OPERATORS
+    value_type
+    fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    {
+        platform_fence_before(order);
+        __asm__ (
+            "lock ; xaddq %0, %1"
+            : "+r" (v), "+m" (v_)
+        );
+        platform_fence_after(order);
+        return reinterpret_cast<value_type>(v);
+    }
+
+    value_type
+    fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    {
+        return fetch_add(-v, order);
+    }
+
+    BOOST_ATOMIC_DECLARE_VOID_POINTER_OPERATORS
 private:
     base_atomic(const base_atomic &) /* = delete */ ;
     void operator=(const base_atomic &) /* = delete */ ;

Modified: trunk/boost/atomic/detail/windows.hpp
==============================================================================
--- trunk/boost/atomic/detail/windows.hpp	(original)
+++ trunk/boost/atomic/detail/windows.hpp	2013-05-08 00:45:38 EDT (Wed, 08 May 2013)
@@ -878,6 +878,7 @@
 class base_atomic<void*, void*, sizeof_pointer, Sign>
 {
     typedef base_atomic this_type;
+    typedef ptrdiff_t difference_type;
     typedef void* value_type;
 public:
     BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT: v_(v) {}
@@ -938,7 +939,22 @@
         return true;
     }
 
-    BOOST_ATOMIC_DECLARE_BASE_OPERATORS
+    value_type
+    fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    {
+        platform_fence_before(order);
+        value_type res = (value_type)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER(&v_, v);
+        platform_fence_after(order);
+        return res;
+    }
+
+    value_type
+    fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
+    {
+        return fetch_add(-v, order);
+    }
+
+    BOOST_ATOMIC_DECLARE_VOID_POINTER_OPERATORS
 private:
     base_atomic(const base_atomic &) /* = delete */ ;
     void operator=(const base_atomic &) /* = delete */ ;

Modified: trunk/libs/atomic/test/api_test_helpers.hpp
==============================================================================
--- trunk/libs/atomic/test/api_test_helpers.hpp	(original)
+++ trunk/libs/atomic/test/api_test_helpers.hpp	2013-05-08 00:45:38 EDT (Wed, 08 May 2013)
@@ -111,8 +111,8 @@
 #endif
 }
 
-template<typename T, typename D>
-void test_additive_operators(T value, D delta)
+template<typename T, typename D, typename AddType>
+void test_additive_operators_with_type(T value, D delta)
 {
     /* note: the tests explicitly cast the result of any addition
     to the type to be tested to force truncation of the result to
@@ -122,14 +122,14 @@
     {
         boost::atomic<T> a(value);
         T n = a.fetch_add(delta);
-        BOOST_CHECK( a.load() == T(value + delta) );
+        BOOST_CHECK( a.load() == T((AddType)value + delta) );
         BOOST_CHECK( n == value );
     }
 
     {
         boost::atomic<T> a(value);
         T n = a.fetch_sub(delta);
-        BOOST_CHECK( a.load() == T(value - delta) );
+        BOOST_CHECK( a.load() == T((AddType)value - delta) );
         BOOST_CHECK( n == value );
     }
 
@@ -137,47 +137,53 @@
     {
         boost::atomic<T> a(value);
         T n = (a += delta);
-        BOOST_CHECK( a.load() == T(value + delta) );
-        BOOST_CHECK( n == T(value + delta) );
+        BOOST_CHECK( a.load() == T((AddType)value + delta) );
+        BOOST_CHECK( n == T((AddType)value + delta) );
     }
 
     {
         boost::atomic<T> a(value);
         T n = (a -= delta);
-        BOOST_CHECK( a.load() == T(value - delta) );
-        BOOST_CHECK( n == T(value - delta) );
+        BOOST_CHECK( a.load() == T((AddType)value - delta) );
+        BOOST_CHECK( n == T((AddType)value - delta) );
     }
 
     /* overloaded increment/decrement */
     {
         boost::atomic<T> a(value);
         T n = a++;
-        BOOST_CHECK( a.load() == T(value + 1) );
+        BOOST_CHECK( a.load() == T((AddType)value + 1) );
         BOOST_CHECK( n == value );
     }
 
     {
         boost::atomic<T> a(value);
         T n = ++a;
-        BOOST_CHECK( a.load() == T(value + 1) );
-        BOOST_CHECK( n == T(value + 1) );
+        BOOST_CHECK( a.load() == T((AddType)value + 1) );
+        BOOST_CHECK( n == T((AddType)value + 1) );
     }
 
     {
         boost::atomic<T> a(value);
         T n = a--;
-        BOOST_CHECK( a.load() == T(value - 1) );
+        BOOST_CHECK( a.load() == T((AddType)value - 1) );
         BOOST_CHECK( n == value );
     }
 
     {
         boost::atomic<T> a(value);
         T n = --a;
-        BOOST_CHECK( a.load() == T(value - 1) );
-        BOOST_CHECK( n == T(value - 1) );
+        BOOST_CHECK( a.load() == T((AddType)value - 1) );
+        BOOST_CHECK( n == T((AddType)value - 1) );
     }
 }
 
+template<typename T, typename D>
+void test_additive_operators(T value, D delta)
+{
+    test_additive_operators_with_type<T, D, T>(value, delta);
+}
+
 template<typename T>
 void test_additive_wrap(T value)
 {
@@ -275,6 +281,7 @@
     test_additive_operators<T*>(&values[1], 1);
 
     test_base_operators<void*>(&values[0], &values[1], &values[2]);
+    test_additive_operators_with_type<void*, int, char*>(&values[1], 1);
 
     boost::atomic<void *> ptr;
     boost::atomic<intptr_t> integral;