mirror of https://github.com/minetest/minetest.git
140 lines
5.1 KiB
C++
140 lines
5.1 KiB
C++
/*
|
|
Minetest
|
|
Copyright (C) 2015 ShadowNinja <shadowninja@minetest.net>
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License along
|
|
with this program; if not, write to the Free Software Foundation, Inc.,
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
#ifndef THREADING_ATOMIC_H
|
|
#define THREADING_ATOMIC_H
|
|
|
|
|
|
#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 (&(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(&(v), &(e), &(d), \
|
|
false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)
|
|
#else
|
|
#define ATOMIC_USE_LOCK
|
|
#include "threading/mutex.h"
|
|
|
|
#define ATOMIC_LOCK_OP(T, op) do { \
|
|
m_mutex.lock(); \
|
|
T _val = (op); \
|
|
m_mutex.unlock(); \
|
|
return _val; \
|
|
} while (0)
|
|
#define ATOMIC_LOCK_CAS(T, v, e, d) do { \
|
|
m_mutex.lock(); \
|
|
bool _eq = (v == e); \
|
|
if (_eq) \
|
|
v = d; \
|
|
m_mutex.unlock(); \
|
|
return _eq; \
|
|
} while (0)
|
|
#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; \
|
|
v = x; \
|
|
m_mutex.unlock(); \
|
|
return _val; \
|
|
} while (0)
|
|
#if GCC_VERSION >= 401
|
|
#define ATOMIC_ADD_EQ(T, v, x) return __sync_add_and_fetch(&(v), (x))
|
|
#define ATOMIC_SUB_EQ(T, v, x) return __sync_sub_and_fetch(&(v), (x))
|
|
#define ATOMIC_POST_INC(T, v) return __sync_fetch_and_add(&(v), 1)
|
|
#define ATOMIC_POST_DEC(T, v) return __sync_fetch_and_sub(&(v), 1)
|
|
#define ATOMIC_CAS(T, v, e, d) return __sync_bool_compare_and_swap(&(v), &(e), (d))
|
|
#else
|
|
#define ATOMIC_ADD_EQ(T, v, x) ATOMIC_LOCK_OP(T, v += x)
|
|
#define ATOMIC_SUB_EQ(T, v, x) ATOMIC_LOCK_OP(T, v -= x)
|
|
#define ATOMIC_POST_INC(T, v) ATOMIC_LOCK_OP(T, v++)
|
|
#define ATOMIC_POST_DEC(T, v) ATOMIC_LOCK_OP(T, v--)
|
|
#define ATOMIC_CAS(T, v, e, d) ATOMIC_LOCK_CAS(T, v, e, d)
|
|
#endif
|
|
#endif
|
|
|
|
// For usage with integral types.
|
|
template<typename T>
|
|
class Atomic {
|
|
public:
|
|
Atomic(const T &v = 0) : m_val(v) {}
|
|
|
|
operator T () { ATOMIC_LOAD(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); }
|
|
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, m_val); }
|
|
T operator -- (int) { ATOMIC_POST_DEC(T, m_val); }
|
|
private:
|
|
T m_val;
|
|
#ifdef ATOMIC_USE_LOCK
|
|
Mutex m_mutex;
|
|
#endif
|
|
};
|
|
|
|
// 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
|