diff options
Diffstat (limited to 'src/threading')
| -rw-r--r-- | src/threading/atomic.h | 64 |
1 files changed, 44 insertions, 20 deletions
diff --git a/src/threading/atomic.h b/src/threading/atomic.h index 9cf50a821..c9a454f20 100644 --- a/src/threading/atomic.h +++ b/src/threading/atomic.h @@ -24,19 +24,25 @@ with this program; if not, write to the Free Software Foundation, Inc., #if __cplusplus >= 201103L #include <atomic> template<typename T> using Atomic = std::atomic<T>; + template<typename T> using GenericAtomic = std::atomic<T>; #else #define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) #define CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) #if GCC_VERSION >= 407 || CLANG_VERSION >= 302 + #define ATOMIC_LOAD_GENERIC(T, v) do { \ + T _val; \ + __atomic_load(&(v), &(_val), __ATOMIC_SEQ_CST); \ + return _val; \ + } while(0) #define ATOMIC_LOAD(T, v) return __atomic_load_n (&(v), __ATOMIC_SEQ_CST) #define ATOMIC_STORE(T, v, x) __atomic_store (&(v), &(x), __ATOMIC_SEQ_CST); return x - #define ATOMIC_EXCHANGE(T, v, x) return __atomic_exchange_n(&(v), (x), __ATOMIC_SEQ_CST) + #define ATOMIC_EXCHANGE(T, v, x) return __atomic_exchange (&(v), &(x), __ATOMIC_SEQ_CST) #define ATOMIC_ADD_EQ(T, v, x) return __atomic_add_fetch (&(v), (x), __ATOMIC_SEQ_CST) #define ATOMIC_SUB_EQ(T, v, x) return __atomic_sub_fetch (&(v), (x), __ATOMIC_SEQ_CST) #define ATOMIC_POST_INC(T, v) return __atomic_fetch_add (&(v), 1, __ATOMIC_SEQ_CST) #define ATOMIC_POST_DEC(T, v) return __atomic_fetch_sub (&(v), 1, __ATOMIC_SEQ_CST) - #define ATOMIC_CAS(T, v, e, d) return __atomic_compare_exchange_n(&(v), &(e), (d), \ + #define ATOMIC_CAS(T, v, e, d) return __atomic_compare_exchange(&(v), &(e), &(d), \ false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) #else #define ATOMIC_USE_LOCK @@ -56,12 +62,9 @@ with this program; if not, write to the Free Software Foundation, Inc., m_mutex.unlock(); \ return _eq; \ } while (0) - #define ATOMIC_LOAD(T, v) \ - if (sizeof(T) <= sizeof(void*)) return v; \ - else ATOMIC_LOCK_OP(T, v); - #define ATOMIC_STORE(T, v, x) \ - if (sizeof(T) <= sizeof(void*)) return v = x; \ - else ATOMIC_LOCK_OP(T, v = x); + #define ATOMIC_LOAD(T, v) ATOMIC_LOCK_OP(T, v) + #define ATOMIC_LOAD_GENERIC(T, v) ATOMIC_LOAD(T, v) + #define ATOMIC_STORE(T, v, x) ATOMIC_LOCK_OP(T, v = x) #define ATOMIC_EXCHANGE(T, v, x) do { \ m_mutex.lock(); \ T _val = v; \ @@ -84,32 +87,53 @@ with this program; if not, write to the Free Software Foundation, Inc., #endif #endif - +// For usage with integral types. template<typename T> class Atomic { public: - Atomic(const T &v = 0) : val(v) {} + Atomic(const T &v = 0) : m_val(v) {} - operator T () { ATOMIC_LOAD(T, val); } + operator T () { ATOMIC_LOAD(T, m_val); } - T exchange(T x) { ATOMIC_EXCHANGE(T, val, x); } - bool compare_exchange_strong(T &expected, T desired) { ATOMIC_CAS(T, val, expected, desired); } + T exchange(T x) { ATOMIC_EXCHANGE(T, m_val, x); } + bool compare_exchange_strong(T &expected, T desired) { ATOMIC_CAS(T, m_val, expected, desired); } - T operator = (T x) { ATOMIC_STORE(T, val, x); } - T operator += (T x) { ATOMIC_ADD_EQ(T, val, x); } - T operator -= (T x) { ATOMIC_SUB_EQ(T, val, x); } + T operator = (T x) { ATOMIC_STORE(T, m_val, x); } + T operator += (T x) { ATOMIC_ADD_EQ(T, m_val, x); } + T operator -= (T x) { ATOMIC_SUB_EQ(T, m_val, x); } T operator ++ () { return *this += 1; } T operator -- () { return *this -= 1; } - T operator ++ (int) { ATOMIC_POST_INC(T, val); } - T operator -- (int) { ATOMIC_POST_DEC(T, val); } + T operator ++ (int) { ATOMIC_POST_INC(T, m_val); } + T operator -- (int) { ATOMIC_POST_DEC(T, m_val); } private: - T val; + T m_val; #ifdef ATOMIC_USE_LOCK Mutex m_mutex; #endif }; -#endif // C++11 +// For usage with non-integral types like float for example. +// Needed because the other operations aren't provided by gcc +// for non-integral types: +// https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/_005f_005fatomic-Builtins.html +template<typename T> +class GenericAtomic { +public: + GenericAtomic(const T &v = 0) : m_val(v) {} + operator T () { ATOMIC_LOAD_GENERIC(T, m_val); } + + T exchange(T x) { ATOMIC_EXCHANGE(T, m_val, x); } + bool compare_exchange_strong(T &expected, T desired) { ATOMIC_CAS(T, m_val, expected, desired); } + + T operator = (T x) { ATOMIC_STORE(T, m_val, x); } +private: + T m_val; +#ifdef ATOMIC_USE_LOCK + Mutex m_mutex; #endif +}; +#endif // C++11 + +#endif |