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"
 
#include <config.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(static_cast<T>(x)) {}
  inline Atomic& operator=(const Atomic& x) {
    return operator=(static_cast<T>(x));
  }
  inline Atomic& operator=(T x) {
    __atomic_store_n(&m_Atom, x, __ATOMIC_SEQ_CST);
    return *this;
  }
  virtual ~Atomic() {}
 
  inline T operator+=(T x) {
    return __sync_add_and_fetch(&m_Atom, x);
  }
  inline T operator-=(T x) {
    return __sync_sub_and_fetch(&m_Atom, x);
  }
  inline T operator|=(T x) {
    return __sync_or_and_fetch(&m_Atom, x);
  }
  inline T operator&=(T x) {
    return __sync_and_and_fetch(&m_Atom, x);
  }
  inline T operator^=(T x) {
    return __sync_xor_and_fetch(&m_Atom, x);
  }
  inline bool compareAndSwap(T oldVal, T newVal) {
    return __sync_bool_compare_and_swap(&m_Atom, oldVal, newVal);
  }
  inline operator T() const {
    return __atomic_load_n(&m_Atom, __ATOMIC_SEQ_CST);
  }
 
  T value() const {
    return static_cast<T>(*this);
  }
 
  typedef T Type;
 
 private:
  volatile T m_Atom;
};
 
template <>
class EXPORTED_PUBLIC Atomic<bool, true> : public Atomic<processor_register_t> {
 public:
  inline Atomic(bool value = false) : Atomic<processor_register_t>((value) ? 1 : 0) {}
  inline Atomic(const Atomic& x) : Atomic<processor_register_t>(x) {}
  inline Atomic& operator=(const Atomic& x) {
    Atomic<processor_register_t>::operator=(x);
    return *this;
  }
  inline Atomic& operator=(bool x) {
    Atomic<processor_register_t>::operator=(x ? 1 : 0);
    return *this;
  }
  virtual ~Atomic();
 
  inline bool operator|=(bool x) {
    return Atomic<processor_register_t>::operator|=(x);
  }
  inline bool operator&=(bool x) {
    return Atomic<processor_register_t>::operator&=(x);
  }
  inline bool operator^=(bool x) {
    return Atomic<processor_register_t>::operator^=(x);
  }
  inline bool compareAndSwap(bool oldVal, bool newVal) {
    return Atomic<processor_register_t>::compareAndSwap((oldVal) ? 1 : 0, (newVal) ? 1 : 0);
  }
  inline operator bool() const {
    return (Atomic<processor_register_t>::operator processor_register_t() == 1) ? true : false;
  }
};
 
#endif