Atomic.h

Go to the documentation of this file.

#ifndef GALOIS_ATOMIC_H
#define GALOIS_ATOMIC_H

#include "Galois/Runtime/ll/CacheLineStorage.h"

#include <iterator>

namespace Galois {

namespace AtomicImpl {
template<typename T, template <typename _> class W>
class GAtomicImpl {
  // Galois::Runtime::LL::CacheLineStorage<T> val;
  W<T> val;

public:
  explicit GAtomicImpl(const T& i): val(i) {}
  GAtomicImpl() {}

  T operator+=(const T& rhs) {
    return __sync_add_and_fetch(&val.data, rhs); 
  }
  T operator-=(const T& rhs) {
    return __sync_sub_and_fetch(&(val.data), rhs); 
  }
  T operator++() {
    return __sync_add_and_fetch(&(val.data), 1);
  }
  T operator++(int) {
    return __sync_fetch_and_add(&(val.data), 1);
  }
  T operator--() { 
    return __sync_sub_and_fetch(&(val.data), 1); 
  }
  T operator--(int) {
    return __sync_fetch_and_sub(&(val.data), 1);
  }
  operator T() const {
    return val.data;
  }
  T& operator=(const T& i) {
    return val.data = i;
  }
  T& operator=(const GAtomicImpl& i) {
    return val.data = i.val.data;
  }
  bool cas (const T& expected, const T& updated) {
    if (val.data != expected) { return false; }
#if defined(__INTEL_COMPILER)
    return __sync_bool_compare_and_swap(
        &val.data, 
        *reinterpret_cast<const ptrdiff_t*>(&expected), 
        *reinterpret_cast<const ptrdiff_t*>(&updated));
#else 
    return __sync_bool_compare_and_swap (&val.data, expected, updated);
#endif
  }
};

template <typename T, template <typename _> class W>
class GAtomicBase: public GAtomicImpl<T, W> {
  typedef GAtomicImpl<T, W> Super_ty;

public:
  explicit GAtomicBase(const T& i): Super_ty (i) {}

  GAtomicBase(): Super_ty () {}

  T& operator=(const GAtomicBase& that) {
    return Super_ty::operator=(that);
  }

  T& operator=(const T& that) {
    return Super_ty::operator=(that);
  }
};

template <typename T, template <typename _> class W>
class GAtomicBase<T*, W>: public GAtomicImpl<T*, W>  {
  typedef GAtomicImpl<T*, W> Super_ty;

public:
  typedef typename std::iterator_traits<T*>::difference_type difference_type;

  GAtomicBase(): Super_ty() {}

  GAtomicBase(T* i): Super_ty(i) {}

  T*& operator=(const GAtomicBase& that) {
    return Super_ty::operator=(that);
  }

  T*& operator=(T* that) {
    return Super_ty::operator=(that);
  }

  T* operator+=(const difference_type& rhs) {
    return __sync_add_and_fetch(&Super_ty::val.data, rhs); 
  }

  T* operator-=(const difference_type& rhs) {
    return __sync_sub_and_fetch(&Super_ty::val.data, rhs);
  }
};

template <typename T, template <typename _> class W>
class GAtomicBase<const T*, W>: public GAtomicImpl<const T*, W>  {
  typedef GAtomicImpl<const T*, W> Super_ty;

public:
  typedef typename std::iterator_traits<const T*>::difference_type difference_type;

  GAtomicBase(): Super_ty() {}

  GAtomicBase(const T* i): Super_ty(i) {}

  const T*& operator=(const GAtomicBase& that) {
    return Super_ty::operator=(that);
  }

  const T*& operator=(const T* that) { 
    return Super_ty::operator=(that);
  }

  const T* operator+=(const difference_type& rhs) {
    return __sync_add_and_fetch(&Super_ty::val.data, rhs); 
  }

  const T* operator-=(const difference_type& rhs) {
    return __sync_sub_and_fetch(&Super_ty::val.data, rhs);
  }
};

template<template <typename _> class W>
class GAtomicBase<bool, W>: private GAtomicImpl<bool, W> {
  typedef GAtomicImpl<bool, W> Super_ty;

public:
  explicit GAtomicBase(bool i): Super_ty(i) {}

  GAtomicBase(): Super_ty() {}

  operator bool() const {
    return Super_ty::operator bool ();
  }

  bool& operator=(const GAtomicBase<bool, W>& i) {
    return Super_ty::operator=(i);
  }

  bool& operator=(bool i) {
    return Super_ty::operator=(i);
  }
  bool cas(bool expected, bool updated) {
    return Super_ty::cas(expected, updated);
  }
};


template <typename T>
struct DummyWrapper {
  T data;

  explicit DummyWrapper(const T& d): data (d) {}
  DummyWrapper() {}
};

} // end namespace impl

template <typename T>
class GAtomic: public AtomicImpl::GAtomicBase <T, AtomicImpl::DummyWrapper> {
  typedef AtomicImpl::GAtomicBase<T, AtomicImpl::DummyWrapper> Super_ty;

public:
  GAtomic(): Super_ty() {}
  explicit GAtomic(const T& v): Super_ty(v) {}

  T& operator=(const GAtomic& that) {
    return Super_ty::operator=(that);
  }

  T& operator=(const T& that) {
    return Super_ty::operator=(that);
  }
};

template <typename T>
class GAtomicPadded: 
  public AtomicImpl::GAtomicBase<T, Galois::Runtime::LL::CacheLineStorage> {

  typedef AtomicImpl::GAtomicBase<T, Galois::Runtime::LL::CacheLineStorage> Super_ty;

public:
  GAtomicPadded(): Super_ty () {}
  explicit GAtomicPadded(const T& v): Super_ty (v) {}

  T& operator=(const GAtomicPadded& that) {
    return Super_ty::operator=(that);
  }

  T& operator=(const T& that) {
    return Super_ty::operator=(that);
  }
};

}

#endif

---