Atomic.h

#ifndef __LDK_ATOMIC_H__
#define __LDK_ATOMIC_H__
#include "LDK/Types.h"

namespace LDK
{

template <typename AddrT, typename OldvalT, typename NewvalT>
inline bool CAS(volatile AddrT *addr, volatile OldvalT oldval, volatile NewvalT newval)
{
    return __sync_bool_compare_and_swap(addr,oldval,newval);
}

template
<
    typename V1T,
    typename V2T
>
union Cas2Data
{
    volatile uint64 m64;
    struct
    {
        volatile V1T m1;
        volatile V2T m2;
    }volatile m32;

    Cas2Data(volatile V1T v1, volatile V2T v2)
    {
        m32.m1 = v1;
        m32.m2 = v2;
    }
};
//this won't work at all as intended on 64-bit :( That would require a 128 bit CAS
//It's not used in atomic types themselves at least.

//__int128_t on amd64
template
<
    typename AddrT,
    typename V1T,
    typename V2T,
    typename N1T,
    typename N2T
>
inline bool CAS2(volatile AddrT * addr, volatile V1T v1, volatile V2T v2, volatile N1T n1, volatile N2T n2)
{
    Cas2Data<V1T,V2T> oldval(v1, v2);
    Cas2Data<N1T,N2T> newval(n1, n2);
    return __sync_bool_compare_and_swap(addr,oldval.m64,newval.m64);
}

template <typename Int>
class Atomic
{
private:

    volatile Int mInt;
    bool operator==(Int rhs) { return false; }

public:

typedef Int Type;

    inline Atomic(volatile Int rhs=0) : mInt(rhs)
    {}
    inline Atomic(const Atomic& rhs) : mInt(rhs.mInt)
    {}
    inline ~Atomic() {}
    inline operator bool() { return !CAS(&mInt,0,mInt); }
    inline volatile Int value() { return mInt; }
    inline volatile Int  operator++()
    {
        Int val;
        do
        {
            val = mInt;
        }while(!CAS(&mInt, val, val+1));
        return val;
    }
    inline volatile Int  operator++(int)
    {
        Int val;
        do
        {
            val = mInt;
        }while(!CAS(&mInt, val, val+1));
        return val;
    }
    inline volatile Int operator--()
    {
        Int val;
        do
        {
            val = mInt;
        }while(!CAS(&mInt, val, val-1));
        return val;
    }
    inline volatile Int operator--(int)
    {
        Int val;
        do
        {
            val = mInt;
        }while(!CAS(&mInt, val, val-1));
        return val;
    }
    //might not need cas for these... hmmm
    inline volatile bool equals(volatile Int rhs) { return CAS(&mInt,rhs,mInt); }
    friend inline volatile bool operator==(const Atomic& lhs, const Atomic& rhs) { return CAS(&lhs.mInt,rhs.mInt,lhs.mInt); }

    inline Atomic& operator=(const Atomic& rhs)
    {
        while(!CAS(&mInt,mInt,rhs.mInt));
        return *this;
    }
    inline Atomic& operator=(volatile Int rhs)
    {
        while(!CAS(&mInt,mInt,rhs));
        return *this;
    }

    inline Atomic& operator+=(const Atomic& rhs)
    {
        Int oldval;
        Int newval;
        do
        {
            oldval = mInt;
            newval = oldval + rhs.mInt;
        }while(!CAS(&mInt,oldval,newval));
        return *this;
    }
    inline Atomic& operator+=(volatile Int rhs)
    {
        Int oldval;
        Int newval;
        do
        {
            oldval = mInt;
            newval = oldval + rhs;
        }while(!CAS(&mInt,oldval,newval));
        return *this;
    }
    friend inline Atomic operator+(const Atomic& lhs, const Atomic& rhs)
    {
        return Atomic(lhs.mInt+rhs.mInt);
    }
    friend inline Atomic operator+(const Atomic& lhs, volatile Int rhs)
    {
        return Atomic(lhs.mInt+rhs);
    }

    inline Atomic& operator-=(const Atomic& rhs)
    {
        Int oldval;
        Int newval;
        do
        {
            oldval = mInt;
            newval = oldval - rhs.mInt;
        }while(!CAS(&mInt,oldval,newval));
        return *this;
    }
    inline Atomic& operator-=(volatile Int rhs)
    {
        Int oldval;
        Int newval;
        do
        {
            oldval = mInt;
            newval = oldval - rhs;
        }while(!CAS(&mInt,oldval,newval));
        return *this;
    }
    friend inline Atomic operator-(const Atomic& lhs, const Atomic& rhs)
    {
        return Atomic(lhs.mInt-rhs.mInt);
    }
    friend inline Atomic operator-(const Atomic& lhs, volatile Int rhs)
    {
        return Atomic(lhs.mInt-rhs);
    }

    inline Atomic& operator*=(const Atomic& rhs)
    {
        Int oldval;
        Int newval;
        do
        {
            oldval = mInt;
            newval = oldval * rhs.mInt;
        }while(!CAS(&mInt,oldval,newval));
        return *this;
    }
    inline Atomic& operator*=(volatile Int rhs)
    {
        Int oldval;
        Int newval;
        do
        {
            oldval = mInt;
            newval = oldval * rhs;
        }while(!CAS(&mInt,oldval,newval));
        return *this;
    }
    friend inline Atomic operator*(const Atomic& lhs, const Atomic& rhs)
    {
        return Atomic(lhs.mInt*rhs.mInt);
    }
    friend inline Atomic operator*(const Atomic& lhs, volatile Int rhs)
    {
        return Atomic(lhs.mInt*rhs);
    }

    inline Atomic& operator/=(const Atomic& rhs)
    {
        Int oldval;
        Int newval;
        do
        {
            oldval = mInt;
            newval = oldval / rhs.mInt;
        }while(!CAS(&mInt,oldval,newval));
        return *this;
    }
    inline Atomic& operator/=(volatile Int rhs)
    {
        Int oldval;
        Int newval;
        do
        {
            oldval = mInt;
            newval = oldval / rhs;
        }while(!CAS(&mInt,oldval,newval));
        return *this;
    }
    friend inline Atomic operator/(const Atomic& lhs, const Atomic& rhs)
    {
        return Atomic(lhs.mInt/rhs.mInt);
    }
    friend inline Atomic operator/(const Atomic& lhs, volatile Int rhs)
    {
        return Atomic(lhs.mInt/rhs);
    }

    inline Atomic& operator&=(const Atomic& rhs)
    {
        Int oldval;
        Int newval;
        do
        {
            oldval = mInt;
            newval = oldval & rhs.mInt;
        }while(!CAS(&mInt,oldval,newval));
        return *this;
    }
    inline Atomic& operator&=(volatile Int rhs)
    {
        Int oldval;
        Int newval;
        do
        {
            oldval = mInt;
            newval = oldval & rhs;
        }while(!CAS(&mInt,oldval,newval));
        return *this;
    }
    friend inline Atomic operator&(const Atomic& lhs, const Atomic& rhs)
    {
        return Atomic(lhs.mInt&rhs.mInt);
    }
    friend inline Atomic operator&(const Atomic& lhs, volatile Int rhs)
    {
        return Atomic(lhs.mInt&rhs);
    }

    inline Atomic& operator|=(const Atomic& rhs)
    {
        Int oldval;
        Int newval;
        do
        {
            oldval = mInt;
            newval = oldval | rhs.mInt;
        }while(!CAS(&mInt,oldval,newval));
        return *this;
    }
    inline Atomic& operator|=(volatile Int rhs)
    {
        Int oldval;
        Int newval;
        do
        {
            oldval = mInt;
            newval = oldval | rhs;
        }while(!CAS(&mInt,oldval,newval));
        return *this;
    }
    friend inline Atomic operator|(const Atomic& lhs, const Atomic& rhs)
    {
        return Atomic(lhs.mInt | rhs.mInt);
    }
    friend inline Atomic operator|(const Atomic& lhs, volatile Int rhs)
    {
        return Atomic(lhs.mInt | rhs);
    }

    inline Atomic& operator^=(const Atomic& rhs)
    {
        Int oldval;
        Int newval;
        do
        {
            oldval = mInt;
            newval = oldval ^ rhs.mInt;
        }while(!CAS(&mInt,oldval,newval));
        return *this;
    }
    inline Atomic& operator^=(volatile Int rhs)
    {
        Int oldval;
        Int newval;
        do
        {
            oldval = mInt;
            newval = oldval ^ rhs;
        }while(!CAS(&mInt,oldval,newval));
        return *this;
    }
    friend inline Atomic operator^(const Atomic& lhs, const Atomic& rhs)
    {
        return Atomic(lhs.mInt ^ rhs.mInt);
    }
    friend inline Atomic operator^(const Atomic& lhs, volatile Int rhs)
    {
        return Atomic(lhs.mInt ^ rhs);
    }
/*
    inline Atomic& operator~=(const Atomic& rhs)
    {
        Int oldval;
        Int newval;
        do
        {
            oldval = mInt;
            newval = oldval ~ rhs.mInt;
        }while(!CAS(&mInt,oldval,newval));
        return *this;
    }
    inline Atomic& operator~=(volatile Int rhs)
    {
        Int oldval;
        Int newval;
        do
        {
            oldval = mInt;
            newval = oldval ~ rhs;
        }while(!CAS(&mInt,oldval,newval));
        return *this;
    }
    friend inline Atomic operator~(const Atomic& lhs, const Atomic& rhs)
    {
        return Atomic(lhs.mInt ~ rhs.mInt);
    }
    friend inline Atomic operator~(const Atomic& lhs, volatile Int rhs)
    {
        return Atomic(lhs.mInt ~ rhs);
    }*/
};

typedef Atomic<uint32> AtomicCount;
} //namespace LDK
#endif //__LDK_ATOMIC_H__

---