AtomicFloat.h

Go to the documentation of this file.

#pragma once
 
 
#include "common/Assert.h"
#include "common/Globals.h"
#include <atomic>
 
NAMESPACE_SPH_BEGIN
 
template <typename Type>
class Atomic {
private:
    std::atomic<Type> value;
 
public:
    INLINE Atomic() = default;
 
    INLINE Atomic(const Type f) {
        value.store(f);
    }
 
    INLINE Atomic(const Atomic& other)
        : Atomic(other.value.load()) {}
 
    INLINE Type get() const {
        return value;
    }
 
    INLINE Atomic& operator=(const Type f) {
        value.store(f);
        return *this;
    }
 
    INLINE Atomic& operator+=(const Type f) {
        atomicOp(f, [](const Type lhs, const Type rhs) { return lhs + rhs; });
        return *this;
    }
 
    INLINE Atomic& operator-=(const Type f) {
        atomicOp(f, [](const Type lhs, const Type rhs) { return lhs - rhs; });
        return *this;
    }
 
    INLINE Atomic& operator*=(const Type f) {
        atomicOp(f, [](const Type lhs, const Type rhs) { return lhs * rhs; });
        return *this;
    }
 
    INLINE Atomic& operator/=(const Type f) {
        SPH_ASSERT(f != 0._f);
        atomicOp(f, [](const Type lhs, const Type rhs) { return lhs / rhs; });
        return *this;
    }
 
    INLINE Type operator+(const Type f) const {
        return value.load() + f;
    }
 
    INLINE Type operator-(const Type f) const {
        return value.load() - f;
    }
 
    INLINE Type operator*(const Type f) const {
        return value.load() * f;
    }
 
    INLINE Type operator/(const Type f) const {
        SPH_ASSERT(f != 0._f);
        return value.load() / f;
    }
 
    INLINE bool operator==(const Type f) const {
        return value.load() == f;
    }
 
    INLINE bool operator!=(const Type f) const {
        return value.load() != f;
    }
 
    INLINE bool operator>(const Type f) const {
        return value.load() > f;
    }
 
    INLINE bool operator<(const Type f) const {
        return value.load() < f;
    }
 
    INLINE friend std::ostream& operator<<(std::ostream& stream, const Atomic& f) {
        stream << f.value.load();
        return stream;
    }
 
private:
    template <typename TOp>
    INLINE Type atomicOp(const Type rhs, const TOp& op) {
        Type lhs = value.load();
        Type desired = op(lhs, rhs);
        while (!value.compare_exchange_weak(lhs, desired)) {
            desired = op(lhs, rhs);
        }
        return desired;
    }
};
 
NAMESPACE_SPH_END