atomic.h

//  Copyright (C) 2007, 2008 Tim Blechmann & Thomas Grill
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)

//  Disclaimer: Not a Boost library.

/* Copyright (c) 2008-2012, Stefan Eilemann <eile@equalizergraphics.com>
   Modifications to use within lunchbox namespace and naming conventions.
   Original at http://tim.klingt.org/git?p=boost_lockfree.git;a=tree
*/

#ifndef LUNCHBOX_ATOMIC_H
#define LUNCHBOX_ATOMIC_H

#include <lunchbox/api.h>
#include <lunchbox/compiler.h> // GCC version
#include <lunchbox/types.h>

#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4985) // inconsistent decl of ceil
#include <intrin.h>
#include <math.h> // include math.h early to avoid warning later
#pragma warning(pop)
#pragma intrinsic(_ReadWriteBarrier)
#elif defined(__xlC__)
#include <builtins.h>
#include <iostream>
#endif

namespace lunchbox
{
inline void memoryBarrier()
{
#ifdef __GNUC__
    __sync_synchronize();
#elif defined(_MSC_VER)
    _ReadWriteBarrier();
#elif defined(__xlC__)
    __fence();
    __eieio();
    __fence();
#else
#error "no memory barrier implemented for this platform"
#endif
}

inline void memoryBarrierAcquire()
{
#ifdef __xlC__
    __fence();
    __eieio();
#else
    memoryBarrier();
#endif
}

inline void memoryBarrierRelease()
{
#ifdef __xlC__
    __isync();
    __fence();
#else
    memoryBarrier();
#endif
}

template <class T>
class Atomic
{
public:
    LUNCHBOX_API static T getAndAdd(T& value, const T increment);

    LUNCHBOX_API static T getAndSub(T& value, const T increment);

    static T addAndGet(T& value, const T increment);

    static T subAndGet(T& value, const T increment);

    LUNCHBOX_API static T incAndGet(T& value);

    LUNCHBOX_API static T decAndGet(T& value);

    LUNCHBOX_API static bool compareAndSwap(T* value, const T expected,
                                            const T newValue);

    explicit Atomic(const T v = 0);

    Atomic(const Atomic<T>& v);

    operator T(void) const;

    void operator=(const T v);

    void operator=(const Atomic<T>& v);

    T operator+=(T v);

    T operator-=(T v);

    T operator++(void);

    T operator--(void);

    T operator++(int);

    T operator--(int);

    bool operator==(const Atomic<T>& rhs) const;

    bool operator!=(const Atomic<T>& rhs) const;

    bool compareAndSwap(const T expected, const T newValue);

private:
// https://github.com/Eyescale/Lunchbox/issues/8
#if _MSC_VER < 1700
    mutable T _value;
#else
    LB_ALIGN8(mutable T _value);
#endif
};

// Implementation
#ifdef __GNUC__
template <class T>
T Atomic<T>::getAndAdd(T& value, const T increment)
{
    return __sync_fetch_and_add(&value, increment);
}

template <class T>
T Atomic<T>::getAndSub(T& value, const T increment)
{
    return __sync_fetch_and_sub(&value, increment);
}

template <class T>
T Atomic<T>::addAndGet(T& value, const T increment)
{
    return __sync_add_and_fetch(&value, increment);
}

template <class T>
T Atomic<T>::subAndGet(T& value, const T increment)
{
    return __sync_sub_and_fetch(&value, increment);
}

template <class T>
T Atomic<T>::incAndGet(T& value)
{
    return addAndGet(value, 1);
}

template <class T>
T Atomic<T>::decAndGet(T& value)
{
    return subAndGet(value, 1);
}

template <class T>
bool Atomic<T>::compareAndSwap(T* value, const T expected, const T newValue)
{
    return __sync_bool_compare_and_swap(value, expected, newValue);
}

#elif defined(_MSC_VER)

// see also atomic.cpp
template <class T>
T Atomic<T>::addAndGet(T& value, const T increment)
{
    return getAndAdd(value, increment) + increment;
}

template <class T>
T Atomic<T>::subAndGet(T& value, const T increment)
{
    return getAndSub(value, increment) - increment;
}

#else
#ifdef __xlC__
template <class T>
bool Atomic<T>::compareAndSwap(T* value, const T expected, const T newValue)
{
    return __compare_and_swap(value, const_cast<T*>(&expected), newValue);
}
#ifdef __64BIT__
template <>
inline bool Atomic<int64_t>::compareAndSwap(int64_t* value,
                                            const int64_t expected,
                                            const int64_t newValue)
{
    return __compare_and_swaplp(value, const_cast<int64_t*>(&expected),
                                newValue);
}
#endif
#else
#error No compare-and-swap implementated for this platform
#endif

template <class T>
T Atomic<T>::getAndAdd(T& value, const T increment)
{
    for (;;)
    {
        memoryBarrierAcquire();
        const T oldv = value;
        const T newv = oldv + increment;
        if (!compareAndSwap(&value, oldv, newv))
            continue;

        memoryBarrierRelease();
        return oldv;
    }
}

template <class T>
T Atomic<T>::getAndSub(T& value, const T increment)
{
    for (;;)
    {
        memoryBarrierAcquire();
        const T oldv = value;
        const T newv = oldv - increment;
        if (!compareAndSwap(&value, oldv, newv))
            continue;

        memoryBarrierRelease();
        return oldv;
    }
}

template <class T>
T Atomic<T>::addAndGet(T& value, const T increment)
{
    for (;;)
    {
        memoryBarrierAcquire();
        const T oldv = value;
        const T newv = oldv + increment;
        if (!Atomic<T>::compareAndSwap(&value, oldv, newv))
            continue;

        memoryBarrierRelease();
        return newv;
    }
}

template <class T>
T Atomic<T>::subAndGet(T& value, const T increment)
{
    for (;;)
    {
        memoryBarrierAcquire();
        const T oldv = value;
        const T newv = oldv - increment;
        if (!Atomic<T>::compareAndSwap(&value, oldv, newv))
            continue;

        memoryBarrierRelease();
        return newv;
    }
}

template <class T>
T Atomic<T>::incAndGet(T& value)
{
    return addAndGet(value, 1);
}

template <class T>
T Atomic<T>::decAndGet(T& value)
{
    return subAndGet(value, 1);
}
#endif

template <class T>
Atomic<T>::Atomic(const T v)
    : _value(v)
{
}

template <class T>
Atomic<T>::Atomic(const Atomic<T>& v)
    : _value(v._value)
{
}

template <class T>
Atomic<T>::operator T(void) const
{
    memoryBarrierAcquire();
    return _value;
}

template <class T>
void Atomic<T>::operator=(const T v)
{
    _value = v;
    memoryBarrier();
}

template <class T>
void Atomic<T>::operator=(const Atomic<T>& v)
{
    _value = v._value;
    memoryBarrier();
}

template <class T>
T Atomic<T>::operator+=(T v)
{
    return addAndGet(_value, v);
}

template <class T>
T Atomic<T>::operator-=(T v)
{
    return subAndGet(_value, v);
}

template <class T>
T Atomic<T>::operator++(void)
{
    return incAndGet(_value);
}

template <class T>
T Atomic<T>::operator--(void)
{
    return decAndGet(_value);
}

template <class T>
T Atomic<T>::operator++(int)
{
    return getAndAdd(_value, 1);
}

template <class T>
T Atomic<T>::operator--(int)
{
    return getAndSub(_value, 1);
}

template <class T>
bool Atomic<T>::operator==(const Atomic<T>& rhs) const
{
    memoryBarrier();
    return _value == rhs._value;
}

template <class T>
bool Atomic<T>::operator!=(const Atomic<T>& rhs) const
{
    memoryBarrier();
    return _value != rhs._value;
}

template <class T>
bool Atomic<T>::compareAndSwap(const T expected, const T newValue)
{
    return compareAndSwap(&_value, expected, newValue);
}
}
#endif // LUNCHBOX_ATOMIC_H