base.hpp

Go to the documentation of this file.

#ifndef BOOST_ATOMIC_DETAIL_ATOMIC_BASE_HPP
#define BOOST_ATOMIC_DETAIL_ATOMIC_BASE_HPP

//  Copyright (c) 2009 Helge Bahmann
//
//  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)

#include "fallback.hpp"
#include "builder.hpp"
#include "valid_integral_types.hpp"

namespace boost_atomic {
namespace detail {
namespace atomic {

static inline memory_order2 calculate_failure_order(memory_order2 order)
{
        switch(order) {
                case memory_order2_acq_rel: return memory_order2_acquire;
                case memory_order2_release: return memory_order2_relaxed;
                default: return order;
        }
}

template<typename T, unsigned short Size=sizeof(T)>
class platform_atomic : public fallback_atomic<T> {
public:
        typedef fallback_atomic<T> super;

        explicit platform_atomic(T v) : super(v) {}
        platform_atomic() {}
protected:
        typedef typename super::integral_type integral_type;
};

template<typename T, unsigned short Size=sizeof(T)>
class platform_atomic_integral : public build_atomic_from_exchange<fallback_atomic<T> > {
public:
        typedef build_atomic_from_exchange<fallback_atomic<T> > super;

        explicit platform_atomic_integral(T v) : super(v) {}
        platform_atomic_integral() {}
protected:
        typedef typename super::integral_type integral_type;
};

template<typename T>
static inline void platform_atomic_thread_fence(T order)
{
        /* FIXME: this does not provide
        sequential consistency, need one global
        variable for that... */
        platform_atomic<int> a;
        a.exchange(0, order);
}

template<typename T, unsigned short Size=sizeof(T), typename Int=typename is_integral_type<T>::test>
class internal_atomic;

template<typename T, unsigned short Size>
class internal_atomic<T, Size, void> : private detail::atomic::platform_atomic<T> {
public:
        typedef detail::atomic::platform_atomic<T> super;

        internal_atomic() {}
        explicit internal_atomic(T v) : super(v) {}

        operator T(void) const volatile {return load();}
        T operator=(T v) volatile {store(v); return v;}

        using super::is_lock_free;
        using super::load;
        using super::store;
        using super::exchange;

        bool compare_exchange_strong(
                T &expected,
                T desired,
                memory_order2 order=memory_order2_seq_cst) volatile
        {
                return super::compare_exchange_strong(expected, desired, order, calculate_failure_order(order));
        }
        bool compare_exchange_weak(
                T &expected,
                T desired,
                memory_order2 order=memory_order2_seq_cst) volatile
        {
                return super::compare_exchange_strong(expected, desired, order, calculate_failure_order(order));
        }
        bool compare_exchange_strong(
                T &expected,
                T desired,
                memory_order2 success_order,
                memory_order2 failure_order) volatile
        {
                return super::compare_exchange_strong(expected, desired, success_order, failure_order);
        }
        bool compare_exchange_weak(
                T &expected,
                T desired,
                memory_order2 success_order,
                memory_order2 failure_order) volatile
        {
                return super::compare_exchange_strong(expected, desired, success_order, failure_order);
        }
private:
        internal_atomic(const internal_atomic &);
        void operator=(const internal_atomic &);
};

template<typename T, unsigned short Size>
class internal_atomic<T, Size, int> : private detail::atomic::platform_atomic_integral<T> {
public:
        typedef detail::atomic::platform_atomic_integral<T> super;
        typedef typename super::integral_type integral_type;

        internal_atomic() {}
        explicit internal_atomic(T v) : super(v) {}

        using super::is_lock_free;
        using super::load;
        using super::store;
        using super::exchange;
        using super::fetch_add;
        using super::fetch_sub;
        using super::fetch_and;
        using super::fetch_or;
        using super::fetch_xor;

        operator integral_type(void) const volatile {return load();}
        integral_type operator=(integral_type v) volatile {store(v); return v;}

        integral_type operator&=(integral_type c) volatile {return fetch_and(c)&c;}
        integral_type operator|=(integral_type c) volatile {return fetch_or(c)|c;}
        integral_type operator^=(integral_type c) volatile {return fetch_xor(c)^c;}

        integral_type operator+=(integral_type c) volatile {return fetch_add(c)+c;}
        integral_type operator-=(integral_type c) volatile {return fetch_sub(c)-c;}

        integral_type operator++(void) volatile {return fetch_add(1)+1;}
        integral_type operator++(int) volatile {return fetch_add(1);}
        integral_type operator--(void) volatile {return fetch_sub(1)-1;}
        integral_type operator--(int) volatile {return fetch_sub(1);}

        bool compare_exchange_strong(
                integral_type &expected,
                integral_type desired,
                memory_order2 order=memory_order2_seq_cst) volatile
        {
                return super::compare_exchange_strong(expected, desired, order, calculate_failure_order(order));
        }
        bool compare_exchange_weak(
                integral_type &expected,
                integral_type desired,
                memory_order2 order=memory_order2_seq_cst) volatile
        {
                return super::compare_exchange_strong(expected, desired, order, calculate_failure_order(order));
        }
        bool compare_exchange_strong(
                integral_type &expected,
                integral_type desired,
                memory_order2 success_order,
                memory_order2 failure_order) volatile
        {
                return super::compare_exchange_strong(expected, desired, success_order, failure_order);
        }
        bool compare_exchange_weak(
                integral_type &expected,
                integral_type desired,
                memory_order2 success_order,
                memory_order2 failure_order) volatile
        {
                return super::compare_exchange_strong(expected, desired, success_order, failure_order);
        }
private:
        internal_atomic(const internal_atomic &);
        void operator=(const internal_atomic &);
};

}
}
}

#endif

---

rosatomic
Author(s): Josh Faust
autogenerated on Fri Jan 11 09:50:22 2013