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

Specialization for atomic values. More...

#include <GlobAtomicRef.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 = GlobRef< atomic_t >
using	const_type = GlobRef< const_atomic_t >
using	nonconst_type = GlobRef< dash::Atomic< nonconst_value_type > >

Public Member Functions
	GlobRef ()=delete
	Reference semantics forbid declaration without definition. More...
	GlobRef (dart_gptr_t dart_gptr)
	Constructor: Create an atomic reference to a element in global memory. More...
template<typename PatternT >
	GlobRef (const GlobPtr< const_atomic_t, PatternT > &gptr)
	Constructor, creates an GlobRef object referencing an element in global memory. More...
template<typename PatternT >
	GlobRef (const GlobPtr< nonconst_atomic_t, PatternT > &gptr)
template<typename _T , int = internal::enable_implicit_copy_ctor<value_type, _T>::value>
	GlobRef (const GlobRef< 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>
	GlobRef (const GlobRef< 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>
	GlobRef (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>
	GlobRef (const GlobAsyncRef< dash::Atomic< _T >> &gref)
	Copy constructor: Explicit if the following conditions are satisfied. More...
	GlobRef (self_t &&other)=default
	Move Constructor. More...
self_t &	operator= (const self_t &other) const
	Copy Assignment: Copies atomically the value from other. More...
self_t &	operator= (self_t &&other)
	Move Assignment: Redirects to Copy Assignment. More...
	operator T () const
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	store (const T &value) const
	Set the value of the shared atomic variable. More...
T	get () const
	atomically fetches value More...
T	load () const
	Get 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 >
T	fetch_op (BinaryOp binary_op, const T &value) const
	Atomic fetch-and-op operation on the referenced shared value. More...
T	exchange (const T &value) const
	Atomically exchanges value. More...
bool	compare_exchange (const T &expected, const T &desired) 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...
T	fetch_add (const T &value) 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...
T	fetch_sub (const T &value) 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_multiply but does not return value. More...
T	fetch_multiply (const T &value) const
	Atomic fetch-and-multiply operation on the referenced shared value. More...
T	operator++ () const
	prefix atomically increment value by one More...
T	operator++ (int) const
	postfix atomically increment value by one More...
T	operator-- () const
	prefix atomically decrement value by one More...
T	operator-- (int) const
	postfix atomically decrement value by one More...
T	operator+= (const T &value) const
	atomically increment value by ref More...
T	operator-= (const T &value) const
	atomically decrement value by ref More...

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

Detailed Description

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

Specialization for atomic values.

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

Definition at line 23 of file GlobAtomicRef.h.

Constructor & Destructor Documentation

GlobRef() [1/9]

template<typename T >

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

delete

Reference semantics forbid declaration without definition.

GlobRef() [2/9]

template<typename T >

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

inlineexplicit

Constructor: Create an atomic reference to a element in global memory.

Definition at line 63 of file GlobAtomicRef.h.

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

GlobRef() [3/9]

template<typename T >

template<typename PatternT >

dash::GlobRef< dash::Atomic< T > >::GlobRef ( const GlobPtr< const_atomic_t, PatternT > &  gptr )

inlineexplicit

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

Parameters

gptr	Pointer to referenced object in global memory

Definition at line 74 of file GlobAtomicRef.h.

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

GlobRef() [4/9]

template<typename T >

template<typename PatternT >

dash::GlobRef< dash::Atomic< T > >::GlobRef ( const GlobPtr< nonconst_atomic_t, PatternT > &  gptr )

inlineexplicit

Parameters

gptr	Pointer to referenced object in global memory

Definition at line 85 of file GlobAtomicRef.h.

    : GlobRef(gptr.dart_gptr())
  {
  }

GlobRef() [5/9]

template<typename T >

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

dash::GlobRef< dash::Atomic< T > >::GlobRef ( const GlobRef< 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 103 of file GlobAtomicRef.h.

    : GlobRef(gref.dart_gptr())
  {
  }

GlobRef() [6/9]

template<typename T >

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

dash::GlobRef< dash::Atomic< T > >::GlobRef ( const GlobRef< 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 117 of file GlobAtomicRef.h.

    : GlobRef(gref.dart_gptr())
  {
  }

GlobRef() [7/9]

template<typename T >

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

dash::GlobRef< dash::Atomic< T > >::GlobRef ( 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 133 of file GlobAtomicRef.h.

    : GlobRef(gref.dart_gptr())
  {
  }

GlobRef() [8/9]

template<typename T >

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

dash::GlobRef< dash::Atomic< T > >::GlobRef ( 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 147 of file GlobAtomicRef.h.

References dash::GlobRef< T >::GlobRef().

    : GlobRef(gref.dart_gptr())
  {
  }

GlobRef() [9/9]

template<typename T >

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

default

Move Constructor.

Member Function Documentation

add()

template<typename T >

void dash::GlobRef< 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 399 of file GlobAtomicRef.h.

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

compare_exchange()

template<typename T >

bool dash::GlobRef< dash::Atomic< T > >::compare_exchange ( const T &  expected, const T &  desired  ) const

inline

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

Returns

True if value is exchanged

See also

dash::atomic::compare_exchange

Definition at line 364 of file GlobAtomicRef.h.

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

exchange()

template<typename T >

T dash::GlobRef< dash::Atomic< T > >::exchange ( const T &  value ) const

inline

Atomically exchanges value.

Definition at line 351 of file GlobAtomicRef.h.

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

fetch_add()

template<typename T >

T dash::GlobRef< dash::Atomic< T > >::fetch_add ( const T &  value ) const

inline

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

Returns

The value of the referenced shared variable before the operation.

Parameters

value

Value to be added to global atomic variable.

Definition at line 413 of file GlobAtomicRef.h.

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

fetch_multiply()

template<typename T >

T dash::GlobRef< dash::Atomic< T > >::fetch_multiply ( const T &  value ) const

inline

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

Returns

The value of the referenced shared variable before the operation.

Parameters

value

Value to be added to global atomic variable.

Definition at line 457 of file GlobAtomicRef.h.

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

fetch_op()

template<typename T >

template<typename BinaryOp >

T dash::GlobRef< dash::Atomic< T > >::fetch_op ( BinaryOp  binary_op, const T &  value  ) const

inline

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

Returns

The value of the referenced shared variable before the operation.

Parameters

value

Value to be added to global atomic variable.

Definition at line 316 of file GlobAtomicRef.h.

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

fetch_sub()

template<typename T >

T dash::GlobRef< dash::Atomic< T > >::fetch_sub ( const T &  value ) const

inline

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

Returns

The value of the referenced shared variable before the operation.

Parameters

value

Value to be subtracted from global atomic variable.

Definition at line 435 of file GlobAtomicRef.h.

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

get()

template<typename T >

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

inline

atomically fetches value

Definition at line 243 of file GlobAtomicRef.h.

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

is_local()

template<typename T >

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

inline

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

Definition at line 188 of file GlobAtomicRef.h.

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

load()

template<typename T >

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

inline

Get the value of the shared atomic variable.

Definition at line 268 of file GlobAtomicRef.h.

  {
    return get();
  }

multiply()

template<typename T >

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

inline

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

Definition at line 446 of file GlobAtomicRef.h.

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

op()

template<typename T >

template<typename BinaryOp >

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

inline

Atomically executes specified operation on the referenced shared value.

Parameters

binary_op	Binary operation to be performed on global atomic variable
value	Value to be used in binary op on global atomic variable.

Definition at line 277 of file GlobAtomicRef.h.

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

operator++() [1/2]

template<typename T >

T dash::GlobRef< dash::Atomic< T > >::operator++ ( ) const

inline

prefix atomically increment value by one

Returns

The value of the referenced shared variable after the operation.

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_arith.

Definition at line 475 of file GlobAtomicRef.h.

  {
    return fetch_add(1) + 1;
  }

operator++() [2/2]

template<typename T >

T dash::GlobRef< dash::Atomic< T > >::operator++ ( int  ) const

inline

postfix atomically increment value by one

Returns

The value of the referenced shared variable before the operation.

Definition at line 486 of file GlobAtomicRef.h.

  {
    return fetch_add(1);
  }

operator+=()

template<typename T >

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

inline

atomically increment value by ref

Returns

The value of the referenced shared variable after the operation.

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_arith2.

Definition at line 529 of file GlobAtomicRef.h.

  {
    return fetch_add(value) + value;
  }

operator--() [1/2]

template<typename T >

T dash::GlobRef< dash::Atomic< T > >::operator-- ( ) const

inline

prefix atomically decrement value by one

Returns

The value of the referenced shared variable after the operation.

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_arith.

Definition at line 502 of file GlobAtomicRef.h.

  {
    return fetch_sub(1) - 1;
  }

operator--() [2/2]

template<typename T >

T dash::GlobRef< dash::Atomic< T > >::operator-- ( int  ) const

inline

postfix atomically decrement value by one

Returns

The value of the referenced shared variable before the operation.

Definition at line 513 of file GlobAtomicRef.h.

  {
    return fetch_sub(1);
  }

operator-=()

template<typename T >

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

inline

atomically decrement value by ref

Returns

The value of the referenced shared variable after the operation.

Note that 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_arith2.

Definition at line 545 of file GlobAtomicRef.h.

  {
    return fetch_sub(value) - value;
  }

operator=() [1/3]

template<typename T >

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

inline

Copy Assignment: Copies atomically the value from other.

Definition at line 160 of file GlobAtomicRef.h.

  {
    store(static_cast<atomic_t>(other));
    return *this;
  }

operator=() [2/3]

template<typename T >

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

inline

Move Assignment: Redirects to Copy Assignment.

Definition at line 169 of file GlobAtomicRef.h.

References dash::GlobRef< T >::operator=().

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

operator=() [3/3]

template<typename T >

T dash::GlobRef< 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 203 of file GlobAtomicRef.h.

  {
    store(value);
    return value;
  }

set()

template<typename T >

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

inline

Set the value of the shared atomic variable.

Definition at line 212 of file GlobAtomicRef.h.

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

store()

template<typename T >

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

inline

Set the value of the shared atomic variable.

Definition at line 237 of file GlobAtomicRef.h.

  {
    set(value);
  }

sub()

template<typename T >

void dash::GlobRef< 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 424 of file GlobAtomicRef.h.

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

---

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

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