dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT > Class Template Reference

A fortran style coarray. More...

#include <Coarray.h>

Public Types
using	value_type = _element_type
using	value_base_type = _base_type
	Same as value_type but without atomic wrapper. More...
using	difference_type = IndexType
using	index_type = IndexType
using	size_type = _size_type
using	iterator = typename _storage_type::iterator
using	const_iterator = typename _storage_type::const_iterator
using	reverse_iterator = typename _storage_type::reverse_iterator
using	const_reverse_iterator = typename _storage_type::const_reverse_iterator
using	reference = typename coarray::detail::ref_type< _element_type >::type
using	const_reference = typename coarray::detail::const_ref_type< _element_type >::type
using	local_pointer = _element_type *
using	const_local_pointer = const _element_type *
template<int subrank>
using	view_type = _view_type< subrank >
using	local_type = _local_ref_type
using	pattern_type = _pattern_type

Public Member Functions
	Coarray (Team &team=Team::All())
	Constructor for scalar types and fully specified array types: More...
template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<(__valuetype_rank != 0)>::type>
	Coarray (const size_type &first_dim, Team &team=Team::All())
	Constructor for array types with one unspecified dimension: More...
template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<(__valuetype_rank == 0)>::type>
	Coarray (const value_type &value, Team &team=Team::All())
constexpr const pattern_type &	pattern () const noexcept
iterator	begin () noexcept
constexpr const_iterator	begin () const noexcept
constexpr const_iterator	cbegin () const noexcept
iterator	end () noexcept
constexpr const_iterator	end () const noexcept
constexpr const_iterator	cend () const noexcept
local_pointer	lbegin () noexcept
constexpr const_local_pointer	lbegin () const noexcept
local_pointer	lend () noexcept
constexpr const_local_pointer	lend () const noexcept
constexpr size_type	size () const noexcept
constexpr bool	empty () const noexcept
void	swap (self_t &&other)
constexpr size_type	local_size () const noexcept
constexpr bool	is_local (index_type gi) const noexcept
void	allocate (Team &team=dash::Team::All())
	allocate an array which was initialized before dash has been initialized More...
void	allocate (const size_type &n, Team &team=dash::Team::All())
	allocate an array which was initialized before dash has been initialized More...
void	deallocate ()
	free the memory allocated by this coarray. More...
Team &	team ()
void	barrier ()
void	sync_all ()
	Blocks until all team members of this container have reached the statement and flushes the memory. More...
template<typename Container >
void	sync_images (const Container &image_ids)
	Blocks until all selected team members of this container have reached the statement and flushes the memory. More...
void	flush ()
void	flush_local ()
template<int __valuetype_rank = _valuetype_rank::value>
view_type< __valuetype_rank >	operator() (const team_unit_t &unit)
	Operator to select remote unit. More...
template<int __valuetype_rank = _valuetype_rank::value>
std::enable_if<(__valuetype_rank !=0), view_type< __valuetype_rank > >::type	operator() (const index_type &unit)
	Operator to select remote unit for array types. More...
template<int __valuetype_rank = _valuetype_rank::value>
std::enable_if<(__valuetype_rank==0), reference >::type	operator() (const index_type &unit)
	Operator to select remote unit for scalar types. More...
template<int __valuetype_rank = _valuetype_rank::value>
std::enable_if<(__valuetype_rank==1 &&!is_atomic< value_type >::value), const local_type >::type	operator[] (const index_type &idx) const
	optimized bracket operator for accessing local elements of 1-D Coarray (const version) More...
template<int __valuetype_rank = _valuetype_rank::value>
std::enable_if<(__valuetype_rank==1 &&!is_atomic< value_type >::value), local_type >::type	operator[] (const index_type &idx)
	optimized bracket operator for accessing local elements of 1-D Coarray More...
template<int __valuetype_rank = _valuetype_rank::value>
std::enable_if<(__valuetype_rank > 1 &&!is_atomic< value_type >::value), local_type >::type	operator[] (const index_type &idx)
	Provides access to local array part. More...
template<int __valuetype_rank = _valuetype_rank::value>
std::enable_if<(__valuetype_rank > 0 &&is_atomic< value_type >::value), local_type >::type	operator[] (const index_type &idx)
	operator for local atomic accesses More...
template<int __valuetype_rank = _valuetype_rank::value>
std::enable_if<(__valuetype_rank==0 &&!is_atomic< value_type >::value), value_type >::type	operator= (const value_type &value)
	allows fortran like local assignment of scalars More...
template<int __valuetype_rank = _valuetype_rank::value>
std::enable_if<(__valuetype_rank==0 &&is_atomic< value_type >::value), value_type >::type	operator= (const value_type &value)
	fortran like local assignment of scalar coarrays of atomic value types More...
template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value)>::type>
	operator value_type () const
	allows fortran like local access of scalars More...
template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && is_atomic<value_type>::value)>::type>
	operator value_base_type ()
	conversion operator for an atomic scalar coarray to the native (non-atomic) type More...
template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<(__valuetype_rank == 0)>::type>
	operator reference ()
	convert scalar Coarray to a global reference. More...
template<typename MEMTYPE , int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<(__valuetype_rank == 0)>::type>
MEMTYPE &	member (size_t offs)
	Get a reference to a member of a certain type at the specified offset. More...
template<class MEMTYPE , class P = T, int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<(__valuetype_rank == 0)>::type>
MEMTYPE &	member (const MEMTYPE P::*mem)
	Get the member via pointer to member. More...
template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value)>::type>
value_type &	operator+= (const value_type &value)
	allows fortran like local access of scalars More...
template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && is_atomic<value_type>::value)>::type>
value_base_type	operator+= (const value_base_type &value)
template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value)>::type>
value_type &	operator-= (const value_type &value)
	allows fortran like local access of scalars More...
template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && is_atomic<value_type>::value)>::type>
value_base_type	operator-= (const value_base_type &value)
template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value)>::type>
value_type &	operator*= (const value_type &value)
	allows fortran like local access of scalars More...
template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && is_atomic<value_type>::value)>::type>
reference	operator*= (const value_type &value)
template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value)>::type>
value_type &	operator/= (const value_type &value)
	allows fortran like local access of scalars More...
template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && is_atomic<value_type>::value)>::type>
reference	operator/= (const value_type &value)
template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value)>::type>
value_type	operator+ (const value_type &value) const
	allows fortran like local access of scalars More...
template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value)>::type>
value_type	operator- (const value_type &value) const
	allows fortran like local access of scalars More...
template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value)>::type>
value_type	operator* (const value_type &value) const
	allows fortran like local access of scalars More...
template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value)>::type>
value_type	operator/ (const value_type &value) const
	allows fortran like local access of scalars More...
template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value)>::type>
value_type &	operator++ ()
	allows fortran like local access of scalars More...
template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && is_atomic<value_type>::value)>::type>
value_base_type	operator++ ()
template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value)>::type>
value_type	operator++ (int)
	allows fortran like local access of scalars More...
template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value)>::type>
value_type &	operator-- ()
	allows fortran like local access of scalars More...
template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && is_atomic<value_type>::value)>::type>
value_base_type	operator-- ()
template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value)>::type>
value_type	operator-- (int)
	allows fortran like local access of scalars More...

Static Public Member Functions
static constexpr dim_t	ndim () noexcept

Detailed Description

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>
class dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >

A fortran style coarray.

Interface of the Coarray for scalar and array types showing local and global accesses:

dash::Coarray<int> i;          // scalar Coarray
dash::Coarray<int[10][20]> x;  // 2D-Coarray
dash::Coarray<int[][20]> y(n); // one open dim,
                               // set at runtime in ctor

// access syntax
i(unit) = value; // global access
i       = value; // local access

x(unit)[idx1][idx2] = value; // global access
x[idx1][idx2]       = value; // local access

Definition at line 184 of file Coarray.h.

Member Typedef Documentation

value_base_type

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

using dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::value_base_type = _base_type

Same as value_type but without atomic wrapper.

Definition at line 220 of file Coarray.h.

Constructor & Destructor Documentation

Coarray() [1/2]

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::Coarray ( Team &  team = Team::All() )

inlineexplicit

Constructor for scalar types and fully specified array types:

dash::Coarray<int>         i;
dash::Coarray<int[10][20]> x;

Definition at line 283 of file Coarray.h.

References dash::is_initialized().

                                            {
    if(dash::is_initialized() &&
        (std::is_array<_base_type>::value == false
         || std::extent<_base_type, 0>::value != 0))
    {
      allocate(team);
    }
  }

Coarray() [2/2]

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<(__valuetype_rank != 0)>::type>

dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::Coarray ( const size_type &  first_dim, Team &  team = Team::All()  )

inlineexplicit

Constructor for array types with one unspecified dimension:

dash::Coarray<int[10][]> y;

Definition at line 301 of file Coarray.h.

References dash::Team::All(), dash::barrier(), dash::begin(), dash::end(), dash::is_initialized(), dash::size(), and dash::swap().

                                                                         {
    if(dash::is_initialized()){
      allocate(first_dim, team);
    }
  }

Member Function Documentation

allocate() [1/2]

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

void dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::allocate ( Team &  team = dash::Team::All() )

inline

allocate an array which was initialized before dash has been initialized

Definition at line 416 of file Coarray.h.

                                                   {
    if(_storage.size() == 0){
      _storage.allocate(_pattern_type(_make_size_spec(),
                                      DistributionSpec<_rank::value>(),
                                      TeamSpec<_rank::value,
                                               IndexType>(team),
                                      team));
    }
  }

allocate() [2/2]

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

void dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::allocate ( const size_type &  n, Team &  team = dash::Team::All()  )

inline

allocate an array which was initialized before dash has been initialized

Definition at line 429 of file Coarray.h.

  {
    if((_storage.size() == 0) && (n > 0)){
      _storage.allocate(_pattern_type(_make_size_spec(n),
                                      DistributionSpec<_rank::value>(),
                                      TeamSpec<_rank::value,
                                               IndexType>(team),
                                      team));
    }
  }

deallocate()

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

void dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::deallocate ( )

inline

free the memory allocated by this coarray.

After deallocation, the coarray cannot be used anymore.

Definition at line 446 of file Coarray.h.

References dash::barrier().

                          {
    _storage.deallocate();
  }

member() [1/2]

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<typename MEMTYPE , int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<(__valuetype_rank == 0)>::type>

MEMTYPE& dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::member ( size_t  offs )

inline

Get a reference to a member of a certain type at the specified offset.

Definition at line 656 of file Coarray.h.

                                       {
    auto *s_begin = reinterpret_cast<char *>(_storage.lbegin());
    s_begin += offs;
    return *(reinterpret_cast<MEMTYPE*>(s_begin));
  }

member() [2/2]

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<class MEMTYPE , class P = T, int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<(__valuetype_rank == 0)>::type>

MEMTYPE& dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::member ( const MEMTYPE P::*  mem )

inline

Get the member via pointer to member.

struct value_t {double a; int b;};
dash::Coarray<value_t> x;
int b = x.member(&value_t::b);

Definition at line 675 of file Coarray.h.

                                               {
    auto offs = (size_t) & (reinterpret_cast<P *>(0)->*mem);
    return member<MEMTYPE>(offs);
  }

operator reference()

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<(__valuetype_rank == 0)>::type>

dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::operator reference ( )

inlineexplicit

convert scalar Coarray to a global reference.

Definition at line 644 of file Coarray.h.

References dash::myid().

                                       {
    return _storage[myid()];
  }

operator value_base_type()

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && is_atomic<value_type>::value)>::type>

dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::operator value_base_type ( )

inline

conversion operator for an atomic scalar coarray to the native (non-atomic) type

Definition at line 634 of file Coarray.h.

                                    {
    return _storage[_myid()];
  }

operator value_type()

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value)>::type>

dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::operator value_type ( ) const

inline

allows fortran like local access of scalars

dash::Coarray<int> i;
i = 42;
int b = i;

Definition at line 621 of file Coarray.h.

                                     {
    return *(_storage.lbegin());
  }

operator()() [1/3]

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<int __valuetype_rank = _valuetype_rank::value>

view_type<__valuetype_rank> dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::operator() ( const team_unit_t &  unit )

inline

Operator to select remote unit.

Definition at line 491 of file Coarray.h.

                                                                          {
    return this->operator ()(static_cast<index_type>(unit));
  }

operator()() [2/3]

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<int __valuetype_rank = _valuetype_rank::value>

std::enable_if<(__valuetype_rank != 0), view_type<__valuetype_rank> >::type dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::operator() ( const index_type &  unit )

inline

Operator to select remote unit for array types.

Definition at line 499 of file Coarray.h.

                                             {
    return _storage[unit];
  }

operator()() [3/3]

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<int __valuetype_rank = _valuetype_rank::value>

std::enable_if<(__valuetype_rank == 0), reference>::type dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::operator() ( const index_type &  unit )

inline

Operator to select remote unit for scalar types.

Definition at line 508 of file Coarray.h.

                                             {
    return _storage.at(unit);
  }

operator*()

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value)>::type>

value_type dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::operator* ( const value_type &  value ) const

inline

allows fortran like local access of scalars

Definition at line 809 of file Coarray.h.

                                                               {
    return *(_storage.lbegin()) * value;
  }

operator*=()

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value)>::type>

value_type& dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::operator*= ( const value_type &  value )

inline

allows fortran like local access of scalars

Definition at line 737 of file Coarray.h.

                                                             {
    return *(_storage.lbegin()) *= value;
  }

operator+()

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value)>::type>

value_type dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::operator+ ( const value_type &  value ) const

inline

allows fortran like local access of scalars

dash::Coarray<int> i;
i = 42;
int b = i + 21;

Definition at line 785 of file Coarray.h.

                                                               {
    return *(_storage.lbegin()) + value;
  }

operator++() [1/2]

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value)>::type>

value_type& dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::operator++ ( )

inline

allows fortran like local access of scalars

Definition at line 833 of file Coarray.h.

                                    {
    return ++(*(_storage.lbegin()));
  }

operator++() [2/2]

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value)>::type>

value_type dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::operator++ ( int  )

inline

allows fortran like local access of scalars

Definition at line 854 of file Coarray.h.

                                      {
    return (*(_storage.lbegin()))++;
  }

operator+=()

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value)>::type>

value_type& dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::operator+= ( const value_type &  value )

inline

allows fortran like local access of scalars

dash::Coarray<int> i;
i = 42;
i += 21;

Definition at line 693 of file Coarray.h.

                                                            {
    return *(_storage.lbegin()) += value;
  }

operator-()

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value)>::type>

value_type dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::operator- ( const value_type &  value ) const

inline

allows fortran like local access of scalars

Definition at line 797 of file Coarray.h.

                                                               {
    return *(_storage.lbegin()) - value;
  }

operator--() [1/2]

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value)>::type>

value_type& dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::operator-- ( )

inline

allows fortran like local access of scalars

Definition at line 866 of file Coarray.h.

                                     {
    return --(*(_storage.lbegin()));
  }

operator--() [2/2]

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value)>::type>

value_type dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::operator-- ( int  )

inline

allows fortran like local access of scalars

Definition at line 887 of file Coarray.h.

References dash::operator-().

                                      {
    return (*(_storage.lbegin()))--;
  }

operator-=()

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value)>::type>

value_type& dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::operator-= ( const value_type &  value )

inline

allows fortran like local access of scalars

Definition at line 715 of file Coarray.h.

                                                            {
    return *(_storage.lbegin()) -= value;
  }

operator/()

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value)>::type>

value_type dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::operator/ ( const value_type &  value ) const

inline

allows fortran like local access of scalars

Definition at line 821 of file Coarray.h.

                                                                {
    return *(_storage.lbegin()) / value;
  }

operator/=()

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<int __valuetype_rank = _valuetype_rank::value, typename = typename std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value)>::type>

value_type& dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::operator/= ( const value_type &  value )

inline

allows fortran like local access of scalars

Definition at line 758 of file Coarray.h.

                                                             {
    return *(_storage.lbegin()) /= value;
  }

operator=() [1/2]

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<int __valuetype_rank = _valuetype_rank::value>

std::enable_if<( __valuetype_rank == 0 && !is_atomic<value_type>::value), value_type>::type dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::operator= ( const value_type &  value )

inline

allows fortran like local assignment of scalars

dash::Coarray<int> i;
i = 42;

Definition at line 591 of file Coarray.h.

                                            {
    return *(_storage.lbegin()) = value;
  }

operator=() [2/2]

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<int __valuetype_rank = _valuetype_rank::value>

std::enable_if<( __valuetype_rank == 0 && is_atomic<value_type>::value), value_type>::type dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::operator= ( const value_type &  value )

inline

fortran like local assignment of scalar coarrays of atomic value types

Definition at line 603 of file Coarray.h.

                                            {
    return operator()(_myid()) = value;
  }

operator[]() [1/4]

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<int __valuetype_rank = _valuetype_rank::value>

std::enable_if<( __valuetype_rank == 1 && !is_atomic<value_type>::value), const local_type>::type dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::operator[] ( const index_type &  idx ) const

inline

optimized bracket operator for accessing local elements of 1-D Coarray (const version)

Definition at line 521 of file Coarray.h.

  {
    return const_cast<const local_type>(
        *(_storage.lbegin()+idx));
  }

operator[]() [2/4]

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<int __valuetype_rank = _valuetype_rank::value>

std::enable_if<( __valuetype_rank == 1 && !is_atomic<value_type>::value), local_type>::type dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::operator[] ( const index_type &  idx )

inline

optimized bracket operator for accessing local elements of 1-D Coarray

Definition at line 535 of file Coarray.h.

                                            {
    return *(_storage.lbegin()+idx);
  }

operator[]() [3/4]

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<int __valuetype_rank = _valuetype_rank::value>

std::enable_if<( __valuetype_rank > 1 && !is_atomic<value_type>::value), local_type>::type dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::operator[] ( const index_type &  idx )

inline

Provides access to local array part.

dash::Coarray<int[10][20]> x;
x[2][3] = 42;

Definition at line 550 of file Coarray.h.

                                            {
    // The Coarray internally is based on dash::Narray, with extents:
    // global: team.size() x T[0] x ... x T[n]
    // local: 1 x T[0] x ... x T[n]
    // The first (0) dimenson of the Narray is used for the Coindex.
    // Example: Coarray<T[10][5]> ~ NArray<T, 3,...>(team.size(), 10, 5)
    //
    // The pattern of the NArray is created in a way, that the offset in the
    // first (0) dimension selects the unit the data is local to. While the
    // dimensionality of the local and global parts are always equal, the rank
    // of the local part is reduced by one (the co-dimension).
    //
    // Hence: deref. first dimension and return a view on the remaining ones.
    // This is logically equivalent to _storage[myid][idx] but uses (faster)
    // local view types
    return _storage.local[0][idx];
  }

operator[]() [4/4]

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<int __valuetype_rank = _valuetype_rank::value>

std::enable_if<( __valuetype_rank > 0 && is_atomic<value_type>::value), local_type>::type dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::operator[] ( const index_type &  idx )

inline

operator for local atomic accesses

Definition at line 575 of file Coarray.h.

                                            {
    // dereference first dimension and return a view on the remaining ones
    return operator()(_myid())[idx];
  }

sync_all()

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

void dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::sync_all ( )

inline

Blocks until all team members of this container have reached the statement and flushes the memory.

Definition at line 462 of file Coarray.h.

                         {
    _storage.barrier();
  }

sync_images()

template<typename T, typename IndexType = dash::default_index_t, MemArrange Arrangement = ROW_MAJOR, typename LocalMemSpaceT = HostSpace>

template<typename Container >

void dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::sync_images ( const Container &  image_ids )

inline

Blocks until all selected team members of this container have reached the statement and flushes the memory.

Definition at line 471 of file Coarray.h.

References dash::coarray::sync_images().

                                                      {
    _storage.flush();
    dash::coarray::sync_images(image_ids);
  }

---

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

• /tmp/tmporruphar/dash/include/dash/Coarray.h