Atomic.h

Go to the documentation of this file.

// Honeycomb, Copyright (C) 2015 NewGamePlus Inc.  Distributed under the Boost Software License v1.0.
#pragma once

#include "Honey/Core/Core.h"

namespace honey
{
namespace atomic
{


enum class Order
{
    relaxed,           
    consume,           
    acquire,           
    release,           
    acqRel,            
    seqCst             
};

} }

#include "Honey/Thread/platform/Atomic.h"

namespace honey
{

namespace atomic
{
    class Op : platform::Op
    {
        typedef platform::Op Super;
    public:

        template<class T>
        static T load(volatile const T& val, Order o = Order::seqCst)               { return Super::load(val, o); }
        using Super::load;

        template<class T>
        static void store(volatile T& dst, T newVal, Order o = Order::seqCst)       { return Super::store(dst, newVal, o); }
        using Super::store;

        template<class T>
        static bool cas(volatile T& dst, T newVal, T cmp, Order o = Order::seqCst)  { return Super::cas(dst, newVal, cmp, o); }

        template<class T>
        static T swap(volatile T& dst, T newVal, Order o = Order::seqCst)           { T v; do { v = dst; } while (!cas(dst, newVal, v, o)); return v; }
        using Super::swap;
        
        template<class T>
        static T inc(volatile T& val, Order o = Order::seqCst)                      { T v; do { v = val; } while (!cas(val, v+1, v, o)); return v; }
        using Super::inc;
        
        template<class T>
        static T dec(volatile T& val, Order o = Order::seqCst)                      { T v; do { v = val; } while (!cas(val, v-1, v, o)); return v; }
        using Super::dec;
        
        template<class T>
        static T add(volatile T& val, T rhs, Order o = Order::seqCst)               { T v; do { v = val; } while (!cas(val, v+rhs, v, o)); return v; }
        
        template<class T>
        static T and_(volatile T& val, T rhs, Order o = Order::seqCst)              { T v; do { v = val; } while (!cas(val, v&rhs, v, o)); return v; }
        
        template<class T>
        static T or_(volatile T& val, T rhs, Order o = Order::seqCst)               { T v; do { v = val; } while (!cas(val, v|rhs, v, o)); return v; }
        
        template<class T>
        static T xor_(volatile T& val, T rhs, Order o = Order::seqCst)              { T v; do { v = val; } while (!cas(val, v^rhs, v, o)); return v; }


        static void fence(Order o = Order::seqCst)                                  { Super::fence(o); }
    };

    typedef platform::SwapMaxType SwapMaxType;

    template<class T> struct SwapType
    {
        static_assert(sizeof(T) <= sizeof(SwapMaxType), "Type too large for atomic ops");
        typedef typename std::conditional<
            sizeof(T) <= sizeof(int32), int32,
            typename std::conditional<sizeof(T) <= sizeof(int64), int64, SwapMaxType>::type
            >::type type;
    };
}

template<class T, bool B = std::is_integral<T>::value>
class Atomic;

template<class T>
class Atomic<T, false>
{
    typedef typename atomic::SwapType<T>::type SwapType;
    typedef atomic::Order Order;
    typedef atomic::Op Op;
    
    //holds a T object in a SwapType value
    struct SwapVal
    {
        SwapVal(T val)                                          { new (&this->val) T(val); }
        SwapType val;
    };
    
public:
    static_assert(std::is_trivially_copyable<T>::value, "Atomic type must be trivially copyable");
    
    Atomic() = default;
    Atomic(T val)                                               { operator=(val); }
    Atomic(const Atomic& val)                                   { operator=(val); }

    T operator=(T val) volatile                                 { store(val); return *this; }
    T operator=(const Atomic& val) volatile                     { store(val); return *this; }

    operator T() const volatile                                 { return load(); }
   
    void store(T val, Order o = Order::seqCst) volatile         { Op::store(_val, SwapVal(val).val, o); }
    T load(Order o = Order::seqCst) const volatile              { auto ret = Op::load(_val, o); return reinterpret_cast<T&>(ret); }

    bool cas(T newVal, T cmp, Order o = Order::seqCst) volatile { return Op::cas(_val, SwapVal(newVal).val, SwapVal(cmp).val, o); }

private:
    SwapType _val;
};

template<class T>
class Atomic<T, true>
{
    typedef typename atomic::SwapType<T>::type SwapType;
    typedef atomic::Order Order;
    typedef atomic::Op Op;
    
public:
    Atomic() = default;
    Atomic(T val)                                               { operator=(val); }
    Atomic(const Atomic& val)                                   { operator=(val); }

    T operator=(T val) volatile                                 { store(val); return *this; }
    T operator=(const Atomic& val) volatile                     { store(val); return *this; }

    T operator++() volatile                                     { return Op::inc(_val) + 1; }
    T operator++(int) volatile                                  { return Op::inc(_val); }
    T operator--() volatile                                     { return Op::dec(_val) - 1; }
    T operator--(int) volatile                                  { return Op::dec(_val); }
    T operator+=(T rhs) volatile                                { return add(rhs); }
    T operator-=(T rhs) volatile                                { return sub(rhs); }
    T operator&=(T rhs) volatile                                { return and_(rhs); }
    T operator|=(T rhs) volatile                                { return or_(rhs); }
    T operator^=(T rhs) volatile                                { return xor_(rhs); }

    operator T() const volatile                                 { return load(); }
   
    void store(T val, Order o = Order::seqCst) volatile         { Op::store(_val, static_cast<SwapType>(val), o); }
    T load(Order o = Order::seqCst) const volatile              { return static_cast<T>(Op::load(_val, o)); }
    T add(T rhs, Order o = Order::seqCst) volatile              { return Op::add(_val, static_cast<SwapType>(rhs), o) + rhs; }
    T sub(T rhs, Order o = Order::seqCst) volatile              { return Op::add(_val, static_cast<SwapType>(-rhs), o) - rhs; }
    T and_(T rhs, Order o = Order::seqCst) volatile             { return Op::and_(_val, static_cast<SwapType>(rhs), o) & rhs; }
    T or_(T rhs, Order o = Order::seqCst) volatile              { return Op::or_(_val, static_cast<SwapType>(rhs), o) | rhs; }
    T xor_(T rhs, Order o = Order::seqCst) volatile             { return Op::xor_(_val, static_cast<SwapType>(rhs), o) ^ rhs; }

    bool cas(T newVal, T cmp, Order o = Order::seqCst) volatile { return Op::cas(_val, static_cast<SwapType>(newVal), static_cast<SwapType>(cmp), o); }

private:
    SwapType _val;
};

template<class T>
class Atomic<T*, false>
{
    typedef typename atomic::SwapType<T*>::type SwapType;
    typedef atomic::Order Order;
    typedef atomic::Op Op;
    
public:
    Atomic() = default;
    Atomic(T* val)                                              { operator=(val); }
    Atomic(const Atomic& val)                                   { operator=(val); }

    T* operator=(T* val) volatile                               { store(val); return *this; }
    T* operator=(const Atomic& val) volatile                    { store(val); return *this; }

    T* operator++() volatile                                    { return reinterpret_cast<T*>(Op::add(_val, sizeof(T))) + 1; }
    T* operator++(int) volatile                                 { return reinterpret_cast<T*>(Op::add(_val, sizeof(T))); }
    T* operator--() volatile                                    { return reinterpret_cast<T*>(Op::add(_val, -sizeof(T))) - 1; }
    T* operator--(int) volatile                                 { return reinterpret_cast<T*>(Op::add(_val, -sizeof(T))); }
    T* operator+=(sdt rhs) volatile                             { return add(rhs); }
    T* operator-=(sdt rhs) volatile                             { return sub(rhs); }

    T* operator->() const volatile                              { return load(); }
    T& operator*() const volatile                               { return *load(); }
    operator T*() const volatile                                { return load(); }

    void store(T* val, Order o = Order::seqCst) volatile        { Op::store(_val, reinterpret_cast<SwapType>(val), o); }
    T* load(Order o = Order::seqCst) const volatile             { return reinterpret_cast<T*>(Op::load(_val, o)); }
    T* add(sdt rhs, Order o = Order::seqCst) volatile           { return reinterpret_cast<T*>(Op::add(_val, rhs*sizeof(T), o)) + rhs; }
    T* sub(sdt rhs, Order o = Order::seqCst) volatile           { return reinterpret_cast<T*>(Op::add(_val, -rhs*sizeof(T), o)) - rhs; }

    bool cas(T* newVal, T* cmp, Order o = Order::seqCst) volatile   { return Op::cas(_val, reinterpret_cast<SwapType>(newVal), reinterpret_cast<SwapType>(cmp), o); }

private:
    SwapType _val;
};

template<class T>
ostream& operator<<(ostream& os, const Atomic<T>& val)          { return os << val.load(); }

}