dash::GlobAsyncRef< dash::Atomic< T > > Class Template Reference

Specialization for atomic values. More...

#include <GlobAtomicAsyncRef.h>

Public Types
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 > >

Public Member Functions
	GlobAsyncRef ()=delete
	Reference semantics forbid declaration without definition. More...
	GlobAsyncRef (dart_gptr_t dart_gptr)
	Constructor, creates an GlobRef object referencing an element in global memory. More...
template<typename _T , int = internal::enable_implicit_copy_ctor<value_type, _T>::value>
	GlobAsyncRef (const GlobAsyncRef< dash::Atomic< _T >> &gref)
	Copy constructor: Implicit if at least one of the following conditions is satisfied: 1) value_type and _T are exactly the same types (including const and volatile qualifiers 2) value_type and _T are the same types after removing const and volatile qualifiers and value_type itself is const. More...
template<typename _T , long = internal::enable_explicit_copy_ctor<value_type, _T>::value>
	GlobAsyncRef (const GlobAsyncRef< dash::Atomic< _T >> &gref)
	Copy constructor: Explicit if the following conditions are satisfied. More...
template<typename _T , int = internal::enable_implicit_copy_ctor<value_type, _T>::value>
	GlobAsyncRef (const GlobRef< dash::Atomic< _T >> &gref)
template<typename _T , long = internal::enable_explicit_copy_ctor<value_type, _T>::value>
	GlobAsyncRef (const GlobRef< dash::Atomic< _T >> &gref)
	GlobAsyncRef (self_t &&other)=default
	MOVE Constructor: Unlike native reference types, global reference types are moveable. More...
self_t &	operator= (const self_t &other)=delete
	Copy Assignment. More...
self_t &	operator= (self_t &&other)=default
	Move Assignment. More...
bool	operator== (const self_t &other) const noexcept
bool	operator!= (const self_t &other) const noexcept
bool	operator== (const T &value) const =delete
bool	operator!= (const T &value) const =delete
dart_gptr_t	dart_gptr () const
bool	is_local () const
	Checks whether the globally referenced element is in the calling unit's local memory. More...
T	operator= (const T &value) const
	atomically assigns value More...
void	set (const T &value) const
	Set the value of the shared atomic variable. More...
void	set (const T *ptr) const
	Set the value of the shared atomic variable. More...
void	store (const T &value) const
	Set the value of the shared atomic variable. More...
void	store (const T *ptr) const
	Set the value of the shared atomic variable. More...
T	get () const
	Atomically fetches the value. More...
void	get (T *result) const
	Atomically fetches the value. More...
T	load () const
	Load the value of the shared atomic variable. More...
template<typename BinaryOp >
void	op (BinaryOp binary_op, const T &value) const
	Atomically executes specified operation on the referenced shared value. More...
template<typename BinaryOp >
void	fetch_op (BinaryOp binary_op, const T &value, T *result) const
	Atomic fetch-and-op operation on the referenced shared value. More...
void	exchange (const T &value, T *result) const
	Atomically exchanges value. More...
void	compare_exchange (const T &expected, const T &desired, T *result) const
	Atomically compares the value with the value of expected and if thosei are bitwise-equal, replaces the former with desired. More...
void	add (const T &value) const
	DASH specific variant which is faster than fetch_add but does not return value. More...
void	fetch_add (const T &value, T *result) const
	Atomic fetch-and-add operation on the referenced shared value. More...
void	sub (const T &value) const
	DASH specific variant which is faster than fetch_sub but does not return value. More...
void	fetch_sub (const T &value, T *result) const
	Atomic fetch-and-sub operation on the referenced shared value. More...
void	multiply (const T &value) const
	DASH specific variant which is faster than fetch_mul but does not return value. More...
void	fetch_multiply (const T &value, T *result) const
	Atomic fetch-and-multiply operation on the referenced shared value. More...
void	flush () const
	Flush all pending asynchronous operations on this asynchronous reference. More...

Friends
template<typename U >
std::ostream &	operator<< (std::ostream &os, const GlobAsyncRef< U > &gref)

Detailed Description

template<typename T>
class dash::GlobAsyncRef< dash::Atomic< T > >

Specialization for atomic values.

All atomic operations are const as the GlobRef does not own the atomic values.

Definition at line 25 of file GlobAtomicAsyncRef.h.

Constructor & Destructor Documentation

GlobAsyncRef() [1/5]

template<typename T >

dash::GlobAsyncRef< dash::Atomic< T > >::GlobAsyncRef ( )

delete

Reference semantics forbid declaration without definition.

GlobAsyncRef() [2/5]

template<typename T >

dash::GlobAsyncRef< dash::Atomic< T > >::GlobAsyncRef ( dart_gptr_t  dart_gptr )

inlineexplicit

Constructor, creates an GlobRef object referencing an element in global memory.

Definition at line 95 of file GlobAtomicAsyncRef.h.

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

GlobAsyncRef() [3/5]

template<typename T >

template<typename _T , int = internal::enable_implicit_copy_ctor<value_type, _T>::value>

dash::GlobAsyncRef< dash::Atomic< T > >::GlobAsyncRef ( const GlobAsyncRef< dash::Atomic< _T >> &  gref )

inline

Copy constructor: Implicit if at least one of the following conditions is satisfied: 1) value_type and _T are exactly the same types (including const and volatile qualifiers 2) value_type and _T are the same types after removing const and volatile qualifiers and value_type itself is const.

Definition at line 111 of file GlobAtomicAsyncRef.h.

  : GlobAsyncRef(gref.dart_gptr())
  { }

GlobAsyncRef() [4/5]

template<typename T >

template<typename _T , long = internal::enable_explicit_copy_ctor<value_type, _T>::value>

dash::GlobAsyncRef< dash::Atomic< T > >::GlobAsyncRef ( const GlobAsyncRef< dash::Atomic< _T >> &  gref )

inlineexplicit

Copy constructor: Explicit if the following conditions are satisfied.

1) value_type and _T are the same types after excluding const and volatile qualifiers 2) value_type is const and _T is non-const

Definition at line 124 of file GlobAtomicAsyncRef.h.

References dash::GlobAsyncRef< T >::dart_gptr(), dash::GlobAsyncRef< T >::get(), dash::GlobAsyncRef< T >::operator=(), and dash::GlobAsyncRef< T >::operator==().

  : GlobAsyncRef(gref.dart_gptr())
  { }

GlobAsyncRef() [5/5]

template<typename T >

dash::GlobAsyncRef< dash::Atomic< T > >::GlobAsyncRef ( self_t &&  other )

default

MOVE Constructor: Unlike native reference types, global reference types are moveable.

Member Function Documentation

add()

template<typename T >

void dash::GlobAsyncRef< dash::Atomic< T > >::add ( const T &  value ) const

inline

DASH specific variant which is faster than fetch_add but does not return value.

Definition at line 407 of file GlobAtomicAsyncRef.h.

  {
    op(dash::plus<nonconst_value_type>(), value);
  }

compare_exchange()

template<typename T >

void dash::GlobAsyncRef< dash::Atomic< T > >::compare_exchange ( const T &  expected, const T &  desired, T *  result  ) const

inline

Atomically compares the value with the value of expected and if thosei are bitwise-equal, replaces the former with desired.

The value before the operation will be stored to the memory location pointed to by result. The operation was succesful if (expected == *result).

The operation will be completed after a call to flush.

See also

dash::atomic::compare_exchange

Definition at line 383 of file GlobAtomicAsyncRef.h.

References dart_compare_and_swap(), and DART_OK.

                            {
    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");
  }

exchange()

template<typename T >

void dash::GlobAsyncRef< dash::Atomic< T > >::exchange ( const T &  value, T *  result  ) const

inline

Atomically exchanges value.

Definition at line 366 of file GlobAtomicAsyncRef.h.

                            {
    fetch_op(dash::second<nonconst_value_type>(), value, result);
  }

fetch_add()

template<typename T >

void dash::GlobAsyncRef< dash::Atomic< T > >::fetch_add ( const T &  value, T *  result  ) const

inline

Atomic fetch-and-add operation on the referenced shared value.

The value before the operation will be stored into the memory location pointed to by result.

The operation will be completed after a call to flush.

Parameters

value	Value to be added to global atomic variable.
result	Pointer to store result to

Definition at line 420 of file GlobAtomicAsyncRef.h.

  {
    fetch_op(dash::plus<nonconst_value_type>(), value, result);
  }

fetch_multiply()

template<typename T >

void dash::GlobAsyncRef< dash::Atomic< T > >::fetch_multiply ( const T &  value, T *  result  ) const

inline

Atomic fetch-and-multiply operation on the referenced shared value.

The value before the operation will be stored into the memory location pointed to by result.

The operation will be completed after a call to flush.

Parameters

value	Value to be subtracted from global atomic variable.
result	Pointer to store result to

Definition at line 472 of file GlobAtomicAsyncRef.h.

  {
    fetch_op(dash::multiply<nonconst_value_type>(), value, result);
  }

fetch_op()

template<typename T >

template<typename BinaryOp >

void dash::GlobAsyncRef< dash::Atomic< T > >::fetch_op ( BinaryOp  binary_op, const T &  value, T *  result  ) const

inline

Atomic fetch-and-op operation on the referenced shared value.

The value before the operation will be stored in result. The operation is guaranteed to be completed after a flush.

Parameters

value

Value to be added to global atomic variable.

Definition at line 343 of file GlobAtomicAsyncRef.h.

References dart_fetch_and_op(), and DART_OK.

  {
    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");
  }

fetch_sub()

template<typename T >

void dash::GlobAsyncRef< dash::Atomic< T > >::fetch_sub ( const T &  value, T *  result  ) const

inline

Atomic fetch-and-sub operation on the referenced shared value.

The value before the operation will be stored into the memory location pointed to by result.

The operation will be completed after a call to flush.

Parameters

value	Value to be subtracted from global atomic variable.
result	Pointer to store result to

Definition at line 446 of file GlobAtomicAsyncRef.h.

  {
    fetch_op(dash::plus<nonconst_value_type>(), -value, result);
  }

flush()

template<typename T >

void dash::GlobAsyncRef< dash::Atomic< T > >::flush ( ) const

inline

Flush all pending asynchronous operations on this asynchronous reference.

Definition at line 484 of file GlobAtomicAsyncRef.h.

References dart_flush(), and DART_OK.

  {
    DASH_ASSERT_RETURNS(
      dart_flush(_gptr),
      DART_OK
    );
  }

get() [1/2]

template<typename T >

T dash::GlobAsyncRef< dash::Atomic< T > >::get ( ) const

inline

Atomically fetches the value.

The operation blocks until the value is available. However, previous un-flushed operations are not serialized.

Definition at line 264 of file GlobAtomicAsyncRef.h.

References dart_fetch_and_op(), dart_flush_local(), DART_OK, and DART_OP_NO_OP.

  {
    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;
  }

get() [2/2]

template<typename T >

void dash::GlobAsyncRef< dash::Atomic< T > >::get ( T *  result ) const

inline

Atomically fetches the value.

The operation will return immediately and is guaranteed to be completed after a flush occured. Previous un-flushed operations are not serialized.

Definition at line 289 of file GlobAtomicAsyncRef.h.

References dart_fetch_and_op(), DART_OK, and DART_OP_NO_OP.

  {
    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");
  }

is_local()

template<typename T >

bool dash::GlobAsyncRef< dash::Atomic< T > >::is_local ( ) const

inline

Checks whether the globally referenced element is in the calling unit's local memory.

Definition at line 180 of file GlobAtomicAsyncRef.h.

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

load()

template<typename T >

T dash::GlobAsyncRef< dash::Atomic< T > >::load ( ) const

inline

Load the value of the shared atomic variable.

The operation blocks until the value is available. However, previous un-flushed operations are not serialized.

Definition at line 309 of file GlobAtomicAsyncRef.h.

                        {
    return get();
  }

multiply()

template<typename T >

void dash::GlobAsyncRef< dash::Atomic< T > >::multiply ( const T &  value ) const

inline

DASH specific variant which is faster than fetch_mul but does not return value.

Definition at line 459 of file GlobAtomicAsyncRef.h.

  {
    op(dash::multiply<nonconst_value_type>(), value);
  }

op()

template<typename T >

template<typename BinaryOp >

void dash::GlobAsyncRef< dash::Atomic< T > >::op ( BinaryOp  binary_op, const T &  value  ) const

inline

Atomically executes specified operation on the referenced shared value.

Parameters

value

Value to be added to global atomic variable.

Definition at line 317 of file GlobAtomicAsyncRef.h.

References dart_accumulate_blocking_local(), and DART_OK.

  {
    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");
  }

operator=() [1/3]

template<typename T >

self_t& dash::GlobAsyncRef< dash::Atomic< T > >::operator= ( const self_t &  other )

delete

Copy Assignment.

operator=() [2/3]

template<typename T >

self_t& dash::GlobAsyncRef< dash::Atomic< T > >::operator= ( self_t &&  other )

default

Move Assignment.

operator=() [3/3]

template<typename T >

T dash::GlobAsyncRef< dash::Atomic< T > >::operator= ( const T &  value ) const

inline

atomically assigns value

Returns

The assigned value.

Note

This operator does not return a reference but a copy of the value in order to ensure atomicity. This is consistent with the C++ std::atomic operator=, see http://en.cppreference.com/w/cpp/atomic/atomic/operator%3D.

Definition at line 194 of file GlobAtomicAsyncRef.h.

                                     {
    store(value);
    return value;
  }

set() [1/2]

template<typename T >

void dash::GlobAsyncRef< dash::Atomic< T > >::set ( const T &  value ) const

inline

Set the value of the shared atomic variable.

The operation will block until the local memory can be re-used.

Definition at line 203 of file GlobAtomicAsyncRef.h.

References dart_accumulate_blocking_local(), DART_OK, and DART_OP_REPLACE.

  {
    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 >");
  }

set() [2/2]

template<typename T >

void dash::GlobAsyncRef< dash::Atomic< T > >::set ( const T *  ptr ) const

inline

Set the value of the shared atomic variable.

The operation will return immediately and the memory pointed to by ptr should not be re-used before the operation has been completed.

Definition at line 224 of file GlobAtomicAsyncRef.h.

References dart_accumulate(), DART_OK, and DART_OP_REPLACE.

  {
    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 >");
  }

store() [1/2]

template<typename T >

void dash::GlobAsyncRef< dash::Atomic< T > >::store ( const T &  value ) const

inline

Set the value of the shared atomic variable.

The operation will block until the local memory can be re-used.

Definition at line 245 of file GlobAtomicAsyncRef.h.

                                           {
    set(value);
  }

store() [2/2]

template<typename T >

void dash::GlobAsyncRef< dash::Atomic< T > >::store ( const T *  ptr ) const

inline

Set the value of the shared atomic variable.

The operation will return immediately and the memory pointed to by ptr should not be re-used before the operation has been completed.

Definition at line 254 of file GlobAtomicAsyncRef.h.

                                         {
    set(ptr);
  }

sub()

template<typename T >

void dash::GlobAsyncRef< dash::Atomic< T > >::sub ( const T &  value ) const

inline

DASH specific variant which is faster than fetch_sub but does not return value.

Definition at line 433 of file GlobAtomicAsyncRef.h.

  {
    op(dash::plus<nonconst_value_type>(), -value);
  }

---

The documentation for this class was generated from the following file:

• /tmp/tmporruphar/dash/include/dash/atomic/GlobAtomicAsyncRef.h