GlobAtomicAsyncRef.h

#ifndef DASH__ATOMIC_ASYNC_GLOBREF_H_
#define DASH__ATOMIC_ASYNC_GLOBREF_H_

#include <dash/Types.h>
#include <dash/GlobPtr.h>
#include <dash/algorithm/Operation.h>
#include <dash/GlobAsyncRef.h>
#include <dash/GlobRef.h>


namespace dash {

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

template<class T>
class GlobRef;

template<typename T>
class GlobAsyncRef<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 GlobAsyncRef<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              = GlobAsyncRef<atomic_t>;
  using const_type          = GlobAsyncRef<const_atomic_t>;
  using nonconst_type       = GlobAsyncRef<dash::Atomic<nonconst_value_type>>;


private:
  dart_gptr_t _gptr{};

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

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



public:
  GlobAsyncRef() = delete;


  explicit GlobAsyncRef(dart_gptr_t dart_gptr)
  : _gptr(dart_gptr)
  {
    DASH_LOG_TRACE_VAR("GlobAsyncRef<Atomic>(dart_gptr_t)", dart_gptr);
  }

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

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

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

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

  ~GlobAsyncRef() = default;

  GlobAsyncRef(self_t && other)      = default;

  self_t & operator=(const self_t & other) = delete;

  self_t & operator=(self_t && other) = default;

  inline bool operator==(const self_t & other) const noexcept
  {
    return this->get() == other.get();
  }

  inline bool operator!=(const self_t & other) const noexcept
  {
    return !(*this == other);
  }

  inline bool operator==(const T & value) const = delete;
  inline bool operator!=(const T & value) const = delete;

  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(std::is_same<value_type, nonconst_value_type>::value,
            "Cannot modify value referenced by GlobAsyncRef<Atomic<const T>>!");
    DASH_LOG_DEBUG_VAR("GlobAsyncRef<Atomic>.set()", value);
    DASH_LOG_TRACE_VAR("GlobAsyncRef<Atomic>.set",   _gptr);
    dart_ret_t ret = dart_accumulate_blocking_local(
                       _gptr,
                       &value,
                       1,
                       dash::dart_punned_datatype<nonconst_value_type>::value,
                       DART_OP_REPLACE);
    DASH_ASSERT_EQ(DART_OK, ret, "dart_accumulate failed");
    DASH_LOG_DEBUG("GlobAsyncRef<Atomic>.set >");
  }

  void set(const T * ptr) const
  {
    static_assert(std::is_same<value_type, nonconst_value_type>::value,
            "Cannot modify value referenced by GlobAsyncRef<Atomic<const T>>!");
    DASH_LOG_DEBUG_VAR("GlobAsyncRef<Atomic>.set()", *ptr);
    DASH_LOG_TRACE_VAR("GlobAsyncRef<Atomic>.set",   _gptr);
    dart_ret_t ret = dart_accumulate(
                       _gptr,
                       ptr,
                       1,
                       dash::dart_punned_datatype<nonconst_value_type>::value,
                       DART_OP_REPLACE);
    DASH_ASSERT_EQ(DART_OK, ret, "dart_accumulate failed");
    DASH_LOG_DEBUG("GlobAsyncRef<Atomic>.set >");
  }


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

  inline void store(const T * ptr) const {
    set(ptr);
  }

  T get() const
  {
    DASH_LOG_DEBUG("GlobAsyncRef<Atomic>.get()");
    DASH_LOG_TRACE_VAR("GlobAsyncRef<Atomic>.get", _gptr);
    nonconst_value_type nothing;
    nonconst_value_type result;
    dart_ret_t ret = dart_fetch_and_op(
                       _gptr,
                       &nothing,
                       &result,
                       dash::dart_punned_datatype<nonconst_value_type>::value,
                       DART_OP_NO_OP);
    dart_flush_local(_gptr);
    DASH_ASSERT_EQ(DART_OK, ret, "dart_accumulate failed");
    DASH_LOG_DEBUG_VAR("GlobAsyncRef<Atomic>.get >", result);
    return result;
  }

  void get(T * result) const
  {
    DASH_LOG_DEBUG("GlobAsyncRef<Atomic>.get()");
    DASH_LOG_TRACE_VAR("GlobAsyncRef<Atomic>.get", _gptr);
    nonconst_value_type nothing;
    dart_ret_t ret = dart_fetch_and_op(
                       _gptr,
                       &nothing,
                       result,
                       dash::dart_punned_datatype<nonconst_value_type>::value,
                       DART_OP_NO_OP);
    DASH_ASSERT_EQ(DART_OK, ret, "dart_accumulate failed");
  }

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

  template<typename BinaryOp>
  void op(
    BinaryOp  binary_op,
    const T & value) const
  {
    static_assert(std::is_same<value_type, nonconst_value_type>::value,
            "Cannot modify value referenced by GlobAsyncRef<Atomic<const T>>!");
    DASH_LOG_DEBUG_VAR("GlobAsyncRef<Atomic>.op()", value);
    DASH_LOG_TRACE_VAR("GlobAsyncRef<Atomic>.op",   _gptr);
    DASH_LOG_TRACE("GlobAsyncRef<Atomic>.op", "dart_accumulate");
    dart_ret_t ret = dart_accumulate_blocking_local(
                       _gptr,
                       &value,
                       1,
                       dash::dart_punned_datatype<nonconst_value_type>::value,
                       binary_op.dart_operation());
    DASH_ASSERT_EQ(DART_OK, ret, "dart_accumulate_blocking_local failed");
  }

  template<typename BinaryOp>
  void fetch_op(
    BinaryOp  binary_op,
    const T & value,
          T * result) const
  {
    static_assert(std::is_same<value_type, nonconst_value_type>::value,
            "Cannot modify value referenced by GlobAsyncRef<Atomic<const T>>!");
    DASH_LOG_DEBUG_VAR("GlobAsyncRef<Atomic>.fetch_op()", value);
    DASH_LOG_TRACE_VAR("GlobAsyncRef<Atomic>.fetch_op",   _gptr);
    DASH_LOG_TRACE_VAR("GlobAsyncRef<Atomic>.fetch_op",   typeid(value).name());
    dart_ret_t ret = dart_fetch_and_op(
                       _gptr,
                       &value,
                       result,
                       dash::dart_punned_datatype<nonconst_value_type>::value,
                       binary_op.dart_operation());
    DASH_ASSERT_EQ(DART_OK, ret, "dart_fetch_op failed");
  }

  void exchange(
    const T & value,
          T * result) const {
    fetch_op(dash::second<nonconst_value_type>(), value, result);
  }

  void compare_exchange(
    const T & expected,
    const T & desired,
          T * result) const {
    static_assert(std::is_same<value_type, nonconst_value_type>::value,
            "Cannot modify value referenced by GlobAsyncRef<Atomic<const T>>!");
    DASH_LOG_DEBUG_VAR("GlobAsyncRef<Atomic>.compare_exchange()", desired);
    DASH_LOG_TRACE_VAR("GlobAsyncRef<Atomic>.compare_exchange",   _gptr);
    DASH_LOG_TRACE_VAR("GlobAsyncRef<Atomic>.compare_exchange",   expected);
    DASH_LOG_TRACE_VAR(
      "GlobAsyncRef<Atomic>.compare_exchange", typeid(desired).name());
    dart_ret_t ret = dart_compare_and_swap(
                       _gptr,
                       &desired,
                       &expected,
                       result,
                       dash::dart_punned_datatype<nonconst_value_type>::value);
    DASH_ASSERT_EQ(DART_OK, ret, "dart_compare_and_swap failed");
  }

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

  void fetch_add(
    const T & value,
          T * result) const
  {
    fetch_op(dash::plus<nonconst_value_type>(), value, result);
  }

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

  void fetch_sub (
    const T & value,
          T * result) const
  {
    fetch_op(dash::plus<nonconst_value_type>(), -value, result);
  }

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

  void fetch_multiply (
    const T & value,
          T * result) const
  {
    fetch_op(dash::multiply<nonconst_value_type>(), value, result);
  }

  void flush() const
  {
    DASH_ASSERT_RETURNS(
      dart_flush(_gptr),
      DART_OK
    );
  }

};

} // namespace dash

#endif // DASH__ATOMIC_ASYNC_GLOBREF_H_