GlobAtomicRef.h

#ifndef DASH__ATOMIC_GLOBREF_H_
#define DASH__ATOMIC_GLOBREF_H_

#include <dash/GlobPtr.h>
//#include <dash/Types.h>
#include <dash/algorithm/Operation.h>
#include <dash/iterator/internal/GlobRefBase.h>

namespace dash {

// forward decls
template <typename T>
class Atomic;


template <typename T>
class GlobAsyncRef;
template <typename T>
class GlobRef<dash::Atomic<T>> {
  /* Notes on type compatibility:
   *
   * - The general support of atomic operations on values of type T is
   *   checked in `dash::Atomic` and is not verified here.
   * - Whether arithmetic operations (like `fetch_add`) are supported
   *   for values of type T is implicitly tested in the DASH operation
   *   types (like `dash::plus<T>`) and is not verified here.
   *
   */

  template <typename U>
  friend std::ostream& operator<<(std::ostream& os, const GlobRef<U>& gref);

public:
  using value_type          = T;
  using const_value_type    = typename std::add_const<T>::type;
  using nonconst_value_type = typename std::remove_const<T>::type;
  using atomic_t            = dash::Atomic<T>;
  using const_atomic_t      = typename dash::Atomic<const_value_type>;
  using nonconst_atomic_t   = typename dash::Atomic<nonconst_value_type>;
  using self_t              = GlobRef<atomic_t>;
  using const_type          = GlobRef<const_atomic_t>;
  using nonconst_type       = GlobRef<dash::Atomic<nonconst_value_type>>;

private:
  dart_gptr_t _gptr{};


public:
  GlobRef() = delete;

  //TODO rkowalewski: Clarify constructors by passing various pointer types

  explicit GlobRef(dart_gptr_t dart_gptr)
    : _gptr(dart_gptr)
  {
    DASH_LOG_TRACE_VAR("GlobRef(dart_gptr_t)", dart_gptr);
  }

  template <typename PatternT>
  explicit GlobRef(
      const GlobPtr<const_atomic_t, PatternT>& gptr)
    : GlobRef(gptr.dart_gptr())
  {
    static_assert(
        std::is_same<value_type, const_value_type>::value,
        "Cannot create GlobRef<Atomic<T>> from GlobPtr<Atomic<const T>>!");
  }

  template <typename PatternT>
  explicit GlobRef(
      const GlobPtr<nonconst_atomic_t, PatternT>& gptr)
    : GlobRef(gptr.dart_gptr())
  {
  }

  template <
      typename _T,
      int = internal::enable_implicit_copy_ctor<value_type, _T>::value>
  GlobRef(const GlobRef<dash::Atomic<_T>>& gref)
    : GlobRef(gref.dart_gptr())
  {
  }

  template <
      typename _T,
      long = internal::enable_explicit_copy_ctor<value_type, _T>::value>
  explicit GlobRef(const GlobRef<dash::Atomic<_T>>& gref)
    : GlobRef(gref.dart_gptr())
  {
  }

  template <
      typename _T,
      int = internal::enable_implicit_copy_ctor<value_type, _T>::value>
  GlobRef(const GlobAsyncRef<dash::Atomic<_T>>& gref)
    : GlobRef(gref.dart_gptr())
  {
  }

  template <
      typename _T,
      long = internal::enable_explicit_copy_ctor<value_type, _T>::value>
  explicit GlobRef(const GlobAsyncRef<dash::Atomic<_T>>& gref)
    : GlobRef(gref.dart_gptr())
  {
  }

  GlobRef(self_t&& other) = default;

  self_t& operator=(const self_t& other) const
  {
    store(static_cast<atomic_t>(other));
    return *this;
  }

  self_t& operator=(self_t&& other) {
    operator=(other);
    return *this;
  }

  operator T() const
  {
    return load();
  }

  dart_gptr_t dart_gptr() const
  {
    return _gptr;
  }

  bool is_local() const
  {
    return dash::internal::is_local(_gptr);
  }

  T operator=(const T& value) const
  {
    store(value);
    return value;
  }

  void set(const T& value) const
  {
    static_assert(
        dash::dart_punned_datatype<T>::value != DART_TYPE_UNDEFINED,
        "Basic type or type smaller than 64bit required for "
        "atomic set!");
    static_assert(
        std::is_same<value_type, nonconst_value_type>::value,
        "Cannot modify value referenced by GlobRef<Atomic<const T>>!");
    DASH_LOG_DEBUG_VAR("GlobRef<Atomic>.store()", value);
    DASH_LOG_TRACE_VAR("GlobRef<Atomic>.store", _gptr);
    dart_ret_t ret = dart_accumulate(
        _gptr,
        &value,
        1,
        dash::dart_punned_datatype<T>::value,
        DART_OP_REPLACE);
    dart_flush(_gptr);
    DASH_ASSERT_EQ(DART_OK, ret, "dart_accumulate failed");
    DASH_LOG_DEBUG("GlobRef<Atomic>.store >");
  }

  inline void store(const T& value) const
  {
    set(value);
  }

  T get() const
  {
    static_assert(
        dash::dart_punned_datatype<T>::value != DART_TYPE_UNDEFINED,
        "Basic type or type smaller than 64bit required for "
        "atomic get!");
    DASH_LOG_DEBUG("GlobRef<Atomic>.load()");
    DASH_LOG_TRACE_VAR("GlobRef<Atomic>.load", _gptr);
    nonconst_value_type nothing;
    nonconst_value_type result;
    dart_ret_t          ret = dart_fetch_and_op(
        _gptr,
        &nothing,
        &result,
        dash::dart_punned_datatype<T>::value,
        DART_OP_NO_OP);
    dart_flush_local(_gptr);
    DASH_ASSERT_EQ(DART_OK, ret, "dart_accumulate failed");
    DASH_LOG_DEBUG_VAR("GlobRef<Atomic>.get >", result);
    return result;
  }

  inline T load() const
  {
    return get();
  }

  template <typename BinaryOp>
  void op(
      BinaryOp binary_op,
      const T& value) const
  {
    static_assert(
        dash::dart_punned_datatype<T>::value != DART_TYPE_UNDEFINED,
        "Basic type or type smaller than 64bit required for "
        "atomic operation!");
    static_assert(
        dash::dart_datatype<T>::value != DART_TYPE_UNDEFINED ||
            binary_op.op_kind() != dash::internal::OpKind::ARITHMETIC,
        "Atomic arithmetic operations only valid on basic types");
    static_assert(
        std::is_same<value_type, nonconst_value_type>::value,
        "Cannot modify value referenced by GlobRef<Atomic<const T>>!");
    DASH_LOG_DEBUG_VAR("GlobRef<Atomic>.op()", value);
    DASH_LOG_TRACE_VAR("GlobRef<Atomic>.op", _gptr);
    nonconst_value_type acc = value;
    DASH_LOG_TRACE("GlobRef<Atomic>.op", "dart_accumulate");
    dart_ret_t ret = dart_accumulate(
        _gptr,
        &acc,
        1,
        dash::dart_punned_datatype<T>::value,
        binary_op.dart_operation());
    dart_flush(_gptr);
    DASH_ASSERT_EQ(DART_OK, ret, "dart_accumulate failed");
    DASH_LOG_DEBUG_VAR("GlobRef<Atomic>.op >", acc);
  }

  template <typename BinaryOp>
  T fetch_op(
      BinaryOp binary_op,
      const T& value) const
  {
    static_assert(
        dash::dart_punned_datatype<T>::value != DART_TYPE_UNDEFINED,
        "Basic type or type smaller than 64bit required for "
        "atomic fetch_op!");
    static_assert(
        dash::dart_datatype<T>::value != DART_TYPE_UNDEFINED ||
            binary_op.op_kind() != dash::internal::OpKind::ARITHMETIC,
        "Atomic arithmetic operations only valid on basic types!");
    static_assert(
        std::is_same<value_type, nonconst_value_type>::value,
        "Cannot modify value referenced by GlobRef<Atomic<const T>>!");
    DASH_LOG_DEBUG_VAR("GlobRef<Atomic>.fetch_op()", value);
    DASH_LOG_TRACE_VAR("GlobRef<Atomic>.fetch_op", _gptr);
    DASH_LOG_TRACE_VAR("GlobRef<Atomic>.fetch_op", typeid(value).name());
    nonconst_value_type res;
    dart_ret_t          ret = dart_fetch_and_op(
        _gptr,
        &value,
        &res,
        dash::dart_punned_datatype<T>::value,
        binary_op.dart_operation());
    dart_flush(_gptr);
    DASH_ASSERT_EQ(DART_OK, ret, "dart_fetch_op failed");
    DASH_LOG_DEBUG_VAR("GlobRef<Atomic>.fetch_op >", res);
    return res;
  }

  T exchange(const T& value) const
  {
    return fetch_op(dash::second<T>(), value);
  }

  bool compare_exchange(const T& expected, const T& desired) const
  {
    static_assert(
        dash::dart_punned_datatype<T>::value != DART_TYPE_UNDEFINED,
        "Integral type or type smaller than 64bit required for "
        "compare_exchange!");
    static_assert(
        !std::is_floating_point<T>::value,
        "compare_exchange not available for floating point!");
    static_assert(
        std::is_same<value_type, nonconst_value_type>::value,
        "Cannot modify value referenced by GlobRef<const T>!");
    DASH_LOG_DEBUG_VAR("GlobRef<Atomic>.compare_exchange()", desired);
    DASH_LOG_TRACE_VAR("GlobRef<Atomic>.compare_exchange", _gptr);
    DASH_LOG_TRACE_VAR("GlobRef<Atomic>.compare_exchange", expected);
    DASH_LOG_TRACE_VAR(
        "GlobRef<Atomic>.compare_exchange", typeid(desired).name());
    nonconst_value_type result;
    dart_ret_t          ret = dart_compare_and_swap(
        _gptr,
        &desired,
        &expected,
        &result,
        dash::dart_punned_datatype<T>::value);
    dart_flush(_gptr);
    DASH_ASSERT_EQ(DART_OK, ret, "dart_compare_and_swap failed");
    DASH_LOG_DEBUG_VAR(
        "GlobRef<Atomic>.compare_exchange >", (expected == result));
    return (expected == result);
  }

  void add(const T& value) const
  {
    static_assert(
        std::is_same<value_type, nonconst_value_type>::value,
        "Cannot modify value referenced by GlobRef<const T>!");
    op(dash::plus<T>(), value);
  }

  T fetch_add(
      const T& value) const
  {
    return fetch_op(dash::plus<T>(), value);
  }

  void sub(const T& value) const
  {
    op(dash::plus<T>(), -value);
  }

  T fetch_sub(
      const T& value) const
  {
    return fetch_op(dash::plus<T>(), -value);
  }

  void multiply(const T& value) const
  {
    op(dash::multiply<T>(), value);
  }

  T fetch_multiply(
      const T& value) const
  {
    return fetch_op(dash::multiply<T>(), value);
  }

  T operator++() const
  {
    return fetch_add(1) + 1;
  }

  T operator++(int) const
  {
    return fetch_add(1);
  }

  T operator--() const
  {
    return fetch_sub(1) - 1;
  }

  T operator--(int) const
  {
    return fetch_sub(1);
  }

  T operator+=(const T& value) const
  {
    return fetch_add(value) + value;
  }

  T operator-=(const T& value) const
  {
    return fetch_sub(value) - value;
  }
};

}  // namespace dash

#endif  // DASH__ATOMIC_GLOBREF_H_