atomic.h

Go to the documentation of this file.

// Evo C++ Library
/* Copyright 2019 Justin Crowell
Distributed under the BSD 2-Clause License -- see included file LICENSE.txt for details.
*/

#pragma once
#ifndef INCL_evo_atomic_h
#define INCL_evo_atomic_h

// Includes/Defines
#include "impl/sys.h"
#include "type.h"
#if defined(EVO_CPP11) || (defined(EVO_MSVC_YEAR) && EVO_MSVC_YEAR >= 2012) || defined(EVO_INTEL_VER)
    #include <atomic>
    #define EVO_INTRINSIC_ATOMICS 1     // 1 when compiler supports atomic operations
    #define EVO_STD_ATOMIC 1            // 1 when compiler supports std::atomic and std::atomic_flag
    #define EVO_ATOMIC_PTRMATH 1        // 1 when pointer math works correctly with AtomicPtr, i.e. increment uses sizeof()

    #define EVO_ATOMIC_RELAXED std::memory_order_relaxed

    #define EVO_ATOMIC_CONSUME std::memory_order_consume

    #define EVO_ATOMIC_ACQUIRE std::memory_order_acquire

    #define EVO_ATOMIC_RELEASE std::memory_order_release

    #define EVO_ATOMIC_ACQ_REL std::memory_order_acq_rel

    #define EVO_ATOMIC_SYNC    std::memory_order_seq_cst

    #define EVO_ATOMIC_FENCE(MEM_ORDER) std::atomic_thread_fence(MEM_ORDER)
#elif defined(EVO_GCC_VER) && EVO_GCC_VER >= 407
    // gcc 4.7+ has __atomic built-ins    
    #define EVO_INTRINSIC_ATOMICS 1
    #define EVO_GCC_ATOMICS 1

    #define EVO_ATOMIC_RELAXED __ATOMIC_RELAXED
    #define EVO_ATOMIC_CONSUME __ATOMIC_CONSUME
    #define EVO_ATOMIC_ACQUIRE __ATOMIC_ACQUIRE
    #define EVO_ATOMIC_RELEASE __ATOMIC_RELEASE
    #define EVO_ATOMIC_ACQ_REL __ATOMIC_ACQ_REL
    #define EVO_ATOMIC_SYNC    __ATOMIC_SEQ_CST

    #define EVO_ATOMIC_FENCE(MEM_ORDER) __atomic_thread_fence(MEM_ORDER)

    #define EVO_ATOMIC_FETCH_OP(OP, PTR, VAL, MEM_ORDER) __atomic_fetch_ ## OP (PTR, VAL, MEM_ORDER)
    #define EVO_ATOMIC_OP_FETCH(OP, PTR, VAL, MEM_ORDER) __atomic_ ## OP ## _fetch(PTR, VAL, MEM_ORDER)
#else
    // Legacy
    #define EVO_ATOMIC_RELAXED 0
    #define EVO_ATOMIC_CONSUME 0
    #define EVO_ATOMIC_ACQUIRE 0
    #define EVO_ATOMIC_RELEASE 0
    #define EVO_ATOMIC_ACQ_REL 0
    #define EVO_ATOMIC_SYNC    0

    #if defined(EVO_MSVC_YEAR) || (defined(EVO_GCC_VER) && EVO_GCC_VER < 401)
        // MSVC doesn't support atomics before 2012
        // gcc doesn't support atomics before 4.1
        #define EVO_INTRINSIC_ATOMICS 0
    #else    
        // Legacy __sync built-ins, supported by older gcc and clang, possibly others
        #define EVO_INTRINSIC_ATOMICS 1
        #define EVO_ATOMIC_FENCE(MEM_ORDER) __sync_synchronize()

        #define EVO_ATOMIC_FETCH_OP(OP, PTR, VAL, MEM_ORDER) __sync_fetch_and_ ## OP (PTR, VAL)
        #define EVO_ATOMIC_OP_FETCH(OP, PTR, VAL, MEM_ORDER) __sync_ ## OP ## _and_fetch(PTR, VAL)
    #endif
#endif
#if !EVO_INTRINSIC_ATOMICS
    // Emulate atomics with SysMutex
    #include "impl/systhread.h"
    #define EVO_ATOMIC_PTRMATH 1
#endif

// Check if static initialization is thread safe ("magic statics")
#if defined(EVO_ATOMIC_SAFE_STATICS)
    // Already defined, allow user to override
#else
    #if defined(EVO_MSVC_YEAR)
        #if EVO_MSVC_YEAR >= 2015            // No thread-safe static init until MSVC 2015
            #define EVO_ATOMIC_SAFE_STATICS 1
        #endif
    #elif defined(EVO_CPP11)                // C++11 requires thread-safe static init
        #define EVO_ATOMIC_SAFE_STATICS 1
    #elif defined(EVO_CLANG_VER)            // clang 2.9+
        #if EVO_CLANG_VER >= 209
            #define EVO_ATOMIC_SAFE_STATICS 1
        #endif
    #elif defined(EVO_GCC_VER)              // gcc 4.3+
        #if EVO_GCC_VER >= 403
            #define EVO_ATOMIC_SAFE_STATICS 1
        #endif
    #endif

    #if !defined(EVO_ATOMIC_SAFE_STATICS)

        #define EVO_ATOMIC_SAFE_STATICS 0
    #endif
#endif

// Disable certain MSVC warnings for this file, if !EVO_INTRINSIC_ATOMICS
#if defined(EVO_MSVC_YEAR) && !EVO_INTRINSIC_ATOMICS
    #pragma warning(push)
    #pragma warning(disable:4800 4100)
#endif

// Namespace: evo
namespace evo {


#if defined(EVO_STD_ATOMIC)

    typedef std::memory_order MemOrder;
#else
    typedef int MemOrder;
#endif

// Temp macro to emulate atomic op with mutex
#if !EVO_INTRINSIC_ATOMICS
    #define EVO_TMP_ATOMIC_OP(CODE) { T val; mutex_.lock(); CODE; mutex_.unlock(); return val; }
#endif


#if defined(EVO_STD_ATOMIC)
struct AtomicFlag : public std::atomic_flag {
    #if defined(EVO_CLANG_VER) || defined(EVO_MSVC_YEAR)
        AtomicFlag()  // some compilers don't support ATOMIC_FLAG_INIT init here 
            { clear(); }
    #else

        AtomicFlag() : atomic_flag(ATOMIC_FLAG_INIT)
            { }
    #endif

    #if defined(DOXYGEN)

        void clear(MemOrder mem_order=EVO_ATOMIC_SYNC);

        bool test_and_set(MemOrder mem_order=EVO_ATOMIC_SYNC);
    #endif
#else
struct AtomicFlag {
    AtomicFlag()
        { clear(); }

    void clear(int mem_order=EVO_ATOMIC_SYNC) {
        #if !EVO_INTRINSIC_ATOMICS
            mutex_.lock();
            val_ = 0;
            mutex_.unlock();
        #elif defined(EVO_GCC_ATOMICS)
            __atomic_clear(&val_, mem_order);
        #else
            val_ = 0;
            EVO_ATOMIC_FENCE(mem_order);
        #endif
    }

    bool test_and_set(int mem_order=EVO_ATOMIC_SYNC) {
        #if !EVO_INTRINSIC_ATOMICS
            typedef int T;
            EVO_TMP_ATOMIC_OP(val = val_; val_ = 1)
        #elif defined(EVO_GCC_ATOMICS)
            return __atomic_test_and_set(&val_, mem_order);
        #else
            return !__sync_bool_compare_and_swap(&val_, 0, 1);
        #endif
    }

private:
    #if defined(EVO_GCC_ATOMICS)
        bool val_;
    #else
        int val_;
    #endif

public:
#endif

    void lock() {
        while (test_and_set(EVO_ATOMIC_ACQUIRE))
            { }
    }

    void sleeplock(ulong ms=1) {
        assert(ms > 0);
        while (test_and_set(EVO_ATOMIC_ACQUIRE))
            sleepms(ms);
    }

    void unlock()
        { clear(EVO_ATOMIC_RELEASE); }

private:
#if !EVO_INTRINSIC_ATOMICS
    mutable SysMutex mutex_;
#endif

    // Disable copying
    AtomicFlag(const AtomicFlag&);
    AtomicFlag& operator=(const AtomicFlag&);
};


#if defined(EVO_STD_ATOMIC)
template<class T>
class Atomic : public std::atomic<T>, public SafeBool<Atomic<T> > {
public:
    typedef Atomic<T> This;                 

    This& operator=(T num) {
        this->store(num);
        return *this;
    }

    bool compare_set(T cmpval, T newval, MemOrder mem_order_success=EVO_ATOMIC_SYNC, MemOrder mem_order_failure=EVO_ATOMIC_ACQUIRE)
        { T oldval = cmpval; return this->compare_exchange_strong(oldval, newval, mem_order_success, mem_order_failure); }

    #if defined(DOXYGEN)

        T load(MemOrder mem_order=EVO_ATOMIC_SYNC) const;

        T exchange(T num, MemOrder mem_order=EVO_ATOMIC_SYNC);

        void store(T num, MemOrder mem_order=EVO_ATOMIC_SYNC);
    
        T fetch_add(T num, MemOrder mem_order=EVO_ATOMIC_SYNC);

        T fetch_sub(T num, MemOrder mem_order=EVO_ATOMIC_SYNC);

        T fetch_and(T num, MemOrder mem_order=EVO_ATOMIC_SYNC);

        T fetch_or(T num, MemOrder mem_order=EVO_ATOMIC_SYNC);

        T fetch_xor(T num, MemOrder mem_order=EVO_ATOMIC_SYNC);

        T operator++();

        T operator++(int);

        T operator--();

        T operator--(int);

        T operator+=(T num);

        T operator-=(T num);

        T operator&=(T num);

        T operator|=(T num);

        T operator^=(T num);
    #endif
#else
template<class T>
struct Atomic : public SafeBool<Atomic<T> > {
    typedef Atomic<T> This;     

    T load(int mem_order=EVO_ATOMIC_SYNC) const {
        #if !EVO_INTRINSIC_ATOMICS
            EVO_TMP_ATOMIC_OP(val = val_)
        #elif defined(EVO_GCC_ATOMICS)
            return __atomic_load_n(&val_, mem_order);
        #else
            T val;
            __sync_synchronize();
            val = val_;
            __sync_synchronize();
            return val;
        #endif
    }

    T exchange(T num, int mem_order=EVO_ATOMIC_SYNC) {
        #if !EVO_INTRINSIC_ATOMICS
            EVO_TMP_ATOMIC_OP(val = val_; val_ = num)
        #elif defined(EVO_GCC_ATOMICS)
            return __atomic_exchange_n(&val_, num, mem_order);
        #else
            T prev_val;
            do {
                __sync_synchronize();
                prev_val = val_;
            } while (!__sync_bool_compare_and_swap(&val_, prev_val, num));
            return prev_val;
        #endif
    }

    void store(T num, int mem_order=EVO_ATOMIC_SYNC) {
        #if !EVO_INTRINSIC_ATOMICS
            mutex_.lock();
            val_ = num;
            mutex_.unlock();
        #elif defined(EVO_GCC_ATOMICS)
            __atomic_store_n(&val_, num, mem_order);
        #else
            val_ = num;
            __sync_synchronize();
        #endif
    }

    This& operator=(T num) {
        store(num);
        return *this;
    }

    bool compare_set(T cmpval, T newval, int mem_order_success=EVO_ATOMIC_SYNC, int mem_order_failure=EVO_ATOMIC_SYNC) {
        #if !EVO_INTRINSIC_ATOMICS
            bool replaced = false;
            mutex_.lock();
            if (val_ == cmpval) {
                val_ = newval;
                replaced = true;
            }
            mutex_.unlock();
            return replaced;
        #elif defined(EVO_GCC_ATOMICS)
            return __atomic_compare_exchange_n(&val_, &cmpval, newval, false, mem_order_success, mem_order_failure);
        #else
            return __sync_bool_compare_and_swap(&val_, cmpval, newval);
        #endif
    }

#if EVO_INTRINSIC_ATOMICS
    T fetch_add(T num, int mem_order=EVO_ATOMIC_SYNC)
        { return EVO_ATOMIC_FETCH_OP(add, &val_, num, mem_order); }

    T fetch_sub(T num, int mem_order=EVO_ATOMIC_SYNC)
        { return EVO_ATOMIC_FETCH_OP(sub, &val_, num, mem_order); }

    T fetch_and(T num, int mem_order=EVO_ATOMIC_SYNC)
        { return EVO_ATOMIC_FETCH_OP(and, &val_, num, mem_order); }

    T fetch_or(T num, int mem_order=EVO_ATOMIC_SYNC)
        { return EVO_ATOMIC_FETCH_OP(or, &val_, num, mem_order); }

    T fetch_xor(T num, int mem_order=EVO_ATOMIC_SYNC)
        { return EVO_ATOMIC_FETCH_OP(xor, &val_, num, mem_order); }

    T operator++()
        { return EVO_ATOMIC_OP_FETCH(add, &val_, (T)1, EVO_ATOMIC_SYNC); }

    T operator++(int)
        { return EVO_ATOMIC_FETCH_OP(add, &val_, (T)1, EVO_ATOMIC_SYNC); }

    T operator--()
        { return EVO_ATOMIC_OP_FETCH(sub, &val_, (T)1, EVO_ATOMIC_SYNC); }

    T operator--(int)
        { return EVO_ATOMIC_FETCH_OP(sub, &val_, (T)1, EVO_ATOMIC_SYNC); }

    T operator+=(T num)
        { return EVO_ATOMIC_OP_FETCH(add, &val_, num, EVO_ATOMIC_SYNC); }

    T operator-=(T num)
        { return EVO_ATOMIC_OP_FETCH(sub, &val_, num, EVO_ATOMIC_SYNC); }

    T operator&=(T num)
        { return EVO_ATOMIC_OP_FETCH(and, &val_, num, EVO_ATOMIC_SYNC); }

    T operator|=(T num)
        { return EVO_ATOMIC_OP_FETCH(or, &val_, num, EVO_ATOMIC_SYNC); }

    T operator^=(T num)
        { return EVO_ATOMIC_OP_FETCH(xor, &val_, num, EVO_ATOMIC_SYNC); }

#else
    // Emulate atomic type with mutex
    typedef typename StaticIf<IsPointer<T>::value,ulong,T>::Type NumType;

    T fetch_add(T num, int mem_order=EVO_ATOMIC_SYNC)
        { EVO_TMP_ATOMIC_OP(val = val_; val_ += (NumType)num) }

    T fetch_sub(T num, int mem_order=EVO_ATOMIC_SYNC)
        { EVO_TMP_ATOMIC_OP(val = val_; val_ -= (NumType)num) }

    T fetch_and(T num, int mem_order=EVO_ATOMIC_SYNC)
        { EVO_TMP_ATOMIC_OP(val = val_; val_ &= (NumType)num) }

    T fetch_or(T num, int mem_order=EVO_ATOMIC_SYNC)
        { EVO_TMP_ATOMIC_OP(val = val_; val_ |= (NumType)num) }

    T fetch_xor(T num, int mem_order=EVO_ATOMIC_SYNC)
        { EVO_TMP_ATOMIC_OP(val = val_; val_ ^= (NumType)num) }

    T operator++()
        { EVO_TMP_ATOMIC_OP(val = ++val_) }

    T operator++(int)
        { EVO_TMP_ATOMIC_OP(val = val_; ++val_) }

    T operator--()
        { EVO_TMP_ATOMIC_OP(val = --val_) }

    T operator--(int)
        { EVO_TMP_ATOMIC_OP(val = val_; --val_) }

    T operator+=(T num)
        { EVO_TMP_ATOMIC_OP(val = val_ += (NumType)num) }

    T operator-=(T num)
        { EVO_TMP_ATOMIC_OP(val = val_ -= (NumType)num) }

    T operator&=(T num)
        { EVO_TMP_ATOMIC_OP(val = val_ &= (NumType)num) }

    T operator|=(T num)
        { EVO_TMP_ATOMIC_OP(val = val_ |= (NumType)num) }

    T operator^=(T num)
        { EVO_TMP_ATOMIC_OP(val = val_ ^= (NumType)num) }
#endif

protected:
    T val_;     
#endif
    
public:
    Atomic()
        { this->store(0); }

    Atomic(T num)
        { this->store(num); }

    operator T() const
        { return this->load(); }

    const T operator->() const
        { return this->load(); }

    T operator->()
        { return this->load(); }

    bool operator!() const
        { return !this->load(); }

    bool operator==(const This& num) const
        { return (this == &num || this->load() == num.load()); }

    bool operator==(T num) const
        { return this->load() == num; }

    bool operator!=(const This& num) const
        { return (this != &num && this->load() != num.load()); }

    bool operator!=(T num) const
        { return this->load() != num; }

    bool operator<(T num) const
        { return this->load() < num; }

    bool operator<=(T num) const
        { return this->load() <= num; }

    bool operator>(T num) const
        { return this->load() > num; }

    bool operator>=(T num) const
        { return this->load() >= num; }

private:
#if !EVO_INTRINSIC_ATOMICS
    mutable SysMutex mutex_;
#endif

    // Disable copying
    Atomic(const This&);
    This& operator=(const This&);
};


typedef Atomic<int>    AtomicInt;       
typedef Atomic<uint>   AtomicUInt;      
typedef Atomic<long>   AtomicLong;      
typedef Atomic<ulong>  AtomicULong;     
typedef Atomic<longl>  AtomicLongL;     
typedef Atomic<ulongl> AtomicULongL;    

typedef Atomic<int32>  AtomicInt32;     
typedef Atomic<uint32> AtomicUInt32;    
typedef Atomic<int64>  AtomicInt64;     
typedef Atomic<uint64> AtomicUInt64;    


// Undef temp macro
#if defined(EVO_TMP_ATOMIC_OP)
    #undef EVO_TMP_ATOMIC_OP
#endif

#if defined(_MSC_VER) && !EVO_INTRINSIC_ATOMICS
    #pragma warning(pop)
#endif


template<class T>
class AtomicPtr : public PtrBase<T, Atomic<T*> > {
protected:
    using PtrBase<T, Atomic<T*> >::ptr_;

public:
    typedef AtomicPtr<T>            This;       
    typedef PtrBase<T, Atomic<T*> > Base;       
    typedef PtrBase<T>              PtrBaseT;   

    AtomicPtr()
        { }

    AtomicPtr(T* ptr)
        { ptr_.store(ptr); }

    AtomicPtr(const T* ptr)
        { ptr_.store((T*)ptr); }

    AtomicPtr(const This& src)
        { ptr_.store(src.ptr_.load()); }

    AtomicPtr(const Base& src)
        { ptr_.store(src.ptr_); }

    AtomicPtr(const PtrBaseT& src)
        { ptr_.store(src.ptr_); }

    This& operator=(const This& src)
        { ptr_.store(src.ptr_.load()); return *this; }

    This& operator=(const Base& src)
        { ptr_.store(src.ptr_); return *this; }

    This& operator=(const PtrBaseT& src)
        { ptr_.store(src.ptr_); return *this; }

    This& operator=(T* ptr)
        { ptr_.store(ptr); return *this; }

    This& operator=(const T* ptr)
        { ptr_.store((T*)ptr); return *this; }

    This& clear()
        { ptr_.store(NULL); return *this; }

    T* detach()
        { return ptr_.exchange(NULL); }

    T* operator++() {
    #if defined(EVO_ATOMIC_PTRMATH)
        return ++ptr_;
    #else
        return ptr_ += (T*)sizeof(T);
    #endif
    }

    T* operator++(int) {
    #if defined(EVO_ATOMIC_PTRMATH)
        return ptr_++;
    #else
        return ptr_.fetch_add((T*)sizeof(T));
    #endif
    }

    This& operator+=(int count) {
    #if defined(EVO_STD_ATOMIC)
        ptr_ += count;
    #elif defined(EVO_ATOMIC_PTRMATH)
        ptr_ += (T*)count;
    #else
        ptr_ += (T*)(count * sizeof(T));
    #endif
        return *this;
    }

    T* operator--() {
    #if defined(EVO_ATOMIC_PTRMATH)
        return --ptr_;
    #else
        return ptr_ -= (T*)sizeof(T);
    #endif
    }

    T* operator--(int) {
    #if defined(EVO_ATOMIC_PTRMATH)
        return ptr_--;
    #else
        return ptr_.fetch_sub((T*)sizeof(T));
    #endif
    }

    This& operator-=(int count) {
    #if defined(EVO_STD_ATOMIC)
        ptr_ -= count;
    #elif defined(EVO_ATOMIC_PTRMATH)
        ptr_ -= (T*)count;
    #else
        ptr_ -= (T*)(count * sizeof(T));
    #endif
        return *this;
    }

    using Base::operator==;
    using Base::operator!=;
    using Base::operator<;
    using Base::operator<=;
    using Base::operator>;
    using Base::operator>=;

    bool operator==(const PtrBaseT& ptr) const
        { return ptr_.load() == ptr.ptr_; }

    bool operator!=(const PtrBaseT& ptr) const
        { return ptr_.load() != ptr.ptr_; }

    bool operator<(const PtrBaseT& ptr) const
        { return ptr_.load() < ptr.ptr_; }

    bool operator<=(const PtrBaseT& ptr) const
        { return ptr_.load() <= ptr.ptr_; }

    bool operator>(const PtrBaseT& ptr) const
        { return ptr_.load() > ptr.ptr_; }

    bool operator>=(const PtrBaseT& ptr) const
        { return ptr_.load() >= ptr.ptr_; }
};

template<class T>
class AtomicPtr<T[]> : public PtrBase<T, Atomic<T*> > {
protected:
    using PtrBase<T, Atomic<T*> >::ptr_;

public:
    typedef AtomicPtr<T[]>          This;       
    typedef PtrBase<T, Atomic<T*> > Base;       
    typedef PtrBase<T>              PtrBaseT;   

    AtomicPtr()
        { }

    AtomicPtr(T* ptr)
        { ptr_.store(ptr); }

    AtomicPtr(const T* ptr)
        { ptr_.store((T*)ptr); }

    AtomicPtr(const This& src)
        { ptr_.store(src.ptr_.load()); }

    AtomicPtr(const Base& src)
        { ptr_.store(src.ptr_); }

    AtomicPtr(const PtrBaseT& src)
        { ptr_.store(src.ptr_); }

    This& operator=(const This& src)
        { ptr_.store(src.ptr_.load()); return *this; }

    This& operator=(const Base& src)
        { ptr_.store(src.ptr_); return *this; }

    This& operator=(const PtrBaseT& src)
        { ptr_.store(src.ptr_); return *this; }

    This& operator=(T* ptr)
        { ptr_.store(ptr); return *this; }

    This& operator=(const T* ptr)
        { ptr_.store((T*)ptr); return *this; }

    This& clear()
        { ptr_.store(NULL); return *this; }

    T* detach()
        { return ptr_.exchange(NULL); }

    T* operator++() {
    #if defined(EVO_ATOMIC_PTRMATH)
        return ++ptr_;
    #else
        return ptr_ += (T*)sizeof(T);
    #endif
    }

    T* operator++(int) {
    #if defined(EVO_ATOMIC_PTRMATH)
        return ptr_++;
    #else
        return ptr_.fetch_add((T*)sizeof(T));
    #endif
    }

    This& operator+=(int count) {
    #if defined(EVO_STD_ATOMIC)
        ptr_ += count;
    #elif defined(EVO_ATOMIC_PTRMATH)
        ptr_ += (T*)count;
    #else
        ptr_ += (T*)(count * sizeof(T));
    #endif
        return *this;
    }

    T* operator--() {
    #if defined(EVO_ATOMIC_PTRMATH)
        return --ptr_;
    #else
        return ptr_ -= (T*)sizeof(T);
    #endif
    }

    T* operator--(int) {
    #if defined(EVO_ATOMIC_PTRMATH)
        return ptr_--;
    #else
        return ptr_.fetch_sub((T*)sizeof(T));
    #endif
    }

    This& operator-=(int count) {
    #if defined(EVO_STD_ATOMIC)
        ptr_ -= count;
    #elif defined(EVO_ATOMIC_PTRMATH)
        ptr_ -= (T*)count;
    #else
        ptr_ -= (T*)(count * sizeof(T));
    #endif
        return *this;
    }

    using Base::operator==;
    using Base::operator!=;
    using Base::operator<;
    using Base::operator<=;
    using Base::operator>;
    using Base::operator>=;

    bool operator==(const PtrBaseT& ptr) const
        { return ptr_.load() == ptr.ptr_; }

    bool operator!=(const PtrBaseT& ptr) const
        { return ptr_.load() != ptr.ptr_; }

    bool operator<(const PtrBaseT& ptr) const
        { return ptr_.load() < ptr.ptr_; }

    bool operator<=(const PtrBaseT& ptr) const
        { return ptr_.load() <= ptr.ptr_; }

    bool operator>(const PtrBaseT& ptr) const
        { return ptr_.load() > ptr.ptr_; }

    bool operator>=(const PtrBaseT& ptr) const
        { return ptr_.load() >= ptr.ptr_; }
};


template<class T>
inline bool operator==(const PtrBase<T>& ptr1, const PtrBase<T, Atomic<T*> >& ptr2)
    { return ptr1.ptr_ == ptr2.ptr_.load(); }

template<class T>
inline bool operator!=(const PtrBase<T>& ptr1, const PtrBase<T, Atomic<T*> >& ptr2)
    { return ptr1.ptr_ != ptr2.ptr_.load(); }

template<class T>
inline bool operator<(const PtrBase<T>& ptr1, const PtrBase<T, Atomic<T*> >& ptr2)
    { return ptr1.ptr_ < ptr2.ptr_.load(); }

template<class T>
inline bool operator<=(const PtrBase<T>& ptr1, const PtrBase<T, Atomic<T*> >& ptr2)
    { return ptr1.ptr_ <= ptr2.ptr_.load(); }

template<class T>
inline bool operator>(const PtrBase<T>& ptr1, const PtrBase<T, Atomic<T*> >& ptr2)
    { return ptr1.ptr_ > ptr2.ptr_.load(); }

template<class T>
inline bool operator>=(const PtrBase<T>& ptr1, const PtrBase<T, Atomic<T*> >& ptr2)
    { return ptr1.ptr_ >= ptr2.ptr_.load(); }

} // Namespace: evo
#endif