Atomic.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef KERNEL_ATOMIC_H
#define KERNEL_ATOMIC_H

#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/utility.h"

// NOTE: See http://gcc.gnu.org/onlinedocs/gcc/Atomic-Builtins.html
//       for more information about gcc's builtin atomic operations

template <
    typename T, bool bAllow = (is_integral<T>::value | is_pointer<T>::value)>
class Atomic;

template <typename T>
class EXPORTED_PUBLIC Atomic<T, true>
{
    friend class PerProcessorScheduler;

  public:
    inline Atomic(T value = T()) : m_Atom(value)
    {
    }
    inline Atomic(const Atomic &x) : m_Atom(x.m_Atom)
    {
    }
    inline Atomic &operator=(const Atomic &x)
    {
        m_Atom = x.m_Atom;
        return *this;
    }
    virtual ~Atomic()
    {
    }

    inline T operator+=(T x)
    {
#if !defined(TARGET_HAS_NO_ATOMICS)
        return __sync_add_and_fetch(&m_Atom, x);
#else
        m_Atom += x;
        return m_Atom;
#endif
    }
    inline T operator-=(T x)
    {
#if !defined(TARGET_HAS_NO_ATOMICS)
        return __sync_sub_and_fetch(&m_Atom, x);
#else
        m_Atom -= x;
        return m_Atom;
#endif
    }
    inline T operator|=(T x)
    {
#if !defined(TARGET_HAS_NO_ATOMICS)
        return __sync_or_and_fetch(&m_Atom, x);
#else
        m_Atom |= x;
        return m_Atom;
#endif
    }
    inline T operator&=(T x)
    {
#if !defined(TARGET_HAS_NO_ATOMICS)
        return __sync_and_and_fetch(&m_Atom, x);
#else
        m_Atom &= x;
        return m_Atom;
#endif
    }
    inline T operator^=(T x)
    {
#if !defined(TARGET_HAS_NO_ATOMICS)
        return __sync_xor_and_fetch(&m_Atom, x);
#else
        m_Atom ^= x;
        return m_Atom;
#endif
    }
    inline bool compareAndSwap(T oldVal, T newVal)
    {
#if !defined(TARGET_HAS_NO_ATOMICS)
        return __sync_bool_compare_and_swap(&m_Atom, oldVal, newVal);
#else
        if (m_Atom == oldVal)
        {
            m_Atom = newVal;
            return true;
        }
        return false;
#endif
    }
    inline operator T() const
    {
        return m_Atom;
    }

  private:
    volatile T m_Atom;
};

template <>
class EXPORTED_PUBLIC Atomic<bool, true> : public Atomic<size_t>
{
  public:
    inline Atomic(bool value = false) : Atomic<size_t>((value) ? 1 : 0)
    {
    }
    inline Atomic(const Atomic &x) : Atomic<size_t>(x)
    {
    }
    inline Atomic &operator=(const Atomic &x)
    {
        Atomic<size_t>::operator=(x);
        return *this;
    }
    virtual ~Atomic();

    inline bool operator|=(bool x)
    {
        return Atomic<size_t>::operator|=(x);
    }
    inline bool operator&=(bool x)
    {
        return Atomic<size_t>::operator&=(x);
    }
    inline bool operator^=(bool x)
    {
        return Atomic<size_t>::operator^=(x);
    }
    inline bool compareAndSwap(bool oldVal, bool newVal)
    {
        return Atomic<size_t>::compareAndSwap(
            (oldVal) ? 1 : 0, (newVal) ? 1 : 0);
    }
    inline operator bool() const
    {
        return (Atomic<size_t>::operator size_t() == 1) ? true : false;
    }
};

#endif