Time: use locks again

The Atomic implementation was only partially correct, and was very complex.
Use locks for sake of simplicity, following KISS principle.
Only remaining atomic operation use is time of day speed, because that
really is only read + written.

Also fixes a bug with m_time_conversion_skew only being decremented, never
incremented (Regresion from previous commit).

atomic.h changes:
	* Add GenericAtomic<T> class for non-integral types like floats.

	* Remove some last remainders from atomic.h of the volatile use.

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