dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT > Class Template Reference

A distributed array. More...

#include <Array.h>

Public Types
typedef ElementType	value_type
	Public types as required by iterator concept. More...
typedef IndexType	index_type
typedef std::make_unsigned< IndexType >::type	size_type
typedef std::make_unsigned< IndexType >::type	difference_type
typedef dash::GlobStaticMem< LocalMemSpaceT >	memory_type
typedef dash::GlobalAllocator< value_type, memory_type >	allocator_type
typedef GlobIter< value_type, PatternType, memory_type >	iterator
typedef GlobIter< const value_type, PatternType, memory_type >	const_iterator
typedef std::reverse_iterator< iterator >	reverse_iterator
typedef std::reverse_iterator< const_iterator >	const_reverse_iterator
typedef GlobRef< value_type >	reference
typedef GlobRef< value_type >::const_type	const_reference
typedef iterator::pointer	pointer
typedef pointer::const_type	const_pointer
typedef pointer::local_type	local_pointer
typedef pointer::const_local_type	const_local_pointer
typedef DistributionSpec< 1 >	distribution_spec
typedef PatternType	pattern_type
	Public types as required by dash container concept. More...
typedef LocalArrayRef< value_type, IndexType, PatternType, LocalMemSpaceT >	local_type
typedef ArrayRef< ElementType, IndexType, PatternType, LocalMemSpaceT >	view_type
typedef AsyncArrayRef< value_type, IndexType, PatternType, LocalMemSpaceT >	async_type
typedef std::integral_constant< dim_t, 1 >	rank

Public Member Functions
constexpr	Array (Team &team=dash::Team::Null())
	Default constructor, for delayed allocation. More...
	Array (size_type nelem, const distribution_spec &distribution, Team &team=dash::Team::All())
	Constructor, specifies the array's global capacity and distribution. More...
	Array (size_type nelem, Team &team=dash::Team::All())
	Delegating constructor, specifies the array's global capacity. More...
	Array (size_type nelem, std::initializer_list< value_type > local_elements, const distribution_spec &distribution, Team &team=dash::Team::All())
	Constructor, specifies the array's global capacity, values of local elements and distribution. More...
	Array (size_type nelem, std::initializer_list< value_type > local_elements, Team &team=dash::Team::All())
	Delegating constructor, specifies the array's global capacity and values of local elements. More...
	Array (const PatternType &pattern)
	Constructor, specifies distribution pattern explicitly. More...
	Array (const self_t &other)=delete
	Copy constructor is deleted to prevent unintentional copies of - usually huge - distributed arrays. More...
	Array (self_t &&other) noexcept(std::is_nothrow_move_constructible< memory_type >::value)
	Move construction is supported for the container with the following limitations: More...
self_t &	operator= (const self_t &rhs)=delete
	Assignment operator is deleted to prevent unintentional copies of. More...
self_t &	operator= (self_t &&other)
	Move assignment is supported for the container with the following limitations: More...
	~Array ()
	Destructor, deallocates array elements. More...
constexpr const view_type	block (index_type block_gindex) const
	View at block at given global block offset. More...
constexpr const memory_type &	globmem () const noexcept
	The instance of GlobStaticMem used by this iterator to resolve addresses in global memory. More...
constexpr const_pointer	data () const noexcept
	Global const pointer to the beginning of the array. More...
iterator	begin () noexcept
	Global pointer to the beginning of the array. More...
constexpr const_iterator	begin () const noexcept
	Global pointer to the beginning of the array. More...
iterator	end () noexcept
	Global pointer to the end of the array. More...
constexpr const_iterator	end () const noexcept
	Global pointer to the end of the array. More...
constexpr const ElementType *	lbegin () const noexcept
	Native pointer to the first local element in the array. More...
ElementType *	lbegin () noexcept
	Native pointer to the first local element in the array. More...
constexpr const ElementType *	lend () const noexcept
	Native pointer to the end of the array. More...
ElementType *	lend () noexcept
	Native pointer to the end of the array. More...
reference	operator[] (size_type global_index)
	Subscript assignment operator, not range-checked. More...
constexpr const_reference	operator[] (size_type global_index) const
	Subscript operator, not range-checked. More...
reference	at (size_type global_pos)
	Random access assignment operator, range-checked. More...
const_reference	at (size_type global_pos) const
	Random access operator, range-checked. More...
constexpr size_type	size () const noexcept
	The size of the array. More...
constexpr size_type	capacity () const noexcept
	The number of elements that can be held in currently allocated storage of the array. More...
constexpr Team &	team () const noexcept
	The team containing all units accessing this array. More...
constexpr size_type	lsize () const noexcept
	The number of elements in the local part of the array. More...
constexpr size_type	lcapacity () const noexcept
	The capacity of the local part of the array. More...
constexpr bool	empty () const noexcept
	Checks whether the array is empty. More...
constexpr view_type	local_in (dash::util::Locality::Scope scope) const
constexpr bool	is_local (index_type global_index) const
	Checks whether the given global index is local to the calling unit. More...
void	barrier () const
	Establish a barrier for all units operating on the array, publishing all changes to all units. More...
void	flush () const
	Complete all outstanding non-blocking operations to all units on the array's underlying global memory. More...
void	flush (dash::team_unit_t target) const
	Complete all outstanding non-blocking operations to the specified unit on the array's underlying global memory. More...
void	flush_local () const
	Locally complete all outstanding non-blocking operations to all units on the array's underlying global memory. More...
void	flush_local (dash::team_unit_t target) const
	Locally complete all outstanding non-blocking operations to the specified unit on the array's underlying global memory. More...
constexpr const PatternType &	pattern () const noexcept
	The pattern used to distribute array elements to units. More...
bool	allocate (size_type nelem, dash::DistributionSpec< 1 > distribution, dash::Team &team=dash::Team::All())
	Delayed allocation of global memory using a one-dimensional distribution spec. More...
bool	allocate (size_type nelem, Team &team=dash::Team::All())
	Delayed allocation of global memory using the default blocked distribution spec. More...
bool	allocate (size_type nelem, std::initializer_list< value_type > local_elements, dash::DistributionSpec< 1 > distribution, dash::Team &team=dash::Team::All())
	Delayed allocation of global memory using a one-dimensional distribution spec and initializing values. More...
void	deallocate ()
bool	allocate (const PatternType &pattern)
	Delayed allocation of global memory using the specified pattern. More...

Static Public Member Functions
static constexpr dim_t	ndim ()

Public Attributes
local_type	local
	Local proxy object, allows use in range-based for loops. More...
async_type	async
	Proxy object, provides non-blocking operations on array. More...

Detailed Description

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>
class dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >

A distributed array.

Implemented concept:

Array Concept

Todo:

Add template parameter: class GlobMemType = dash::GlobStaticMem<ElementType>

Note

: Template parameter IndexType could be deduced from pattern type PatternT::index_type

Examples:

ex.02.array-csr/main.cpp, ex.02.array-ctors/main.cpp, ex.02.array-delayed/main.cpp, ex.02.array-local/main.cpp, ex.02.array/main.cpp, ex.03.globref/main.cpp, ex.04.memalloc/main.cpp, ex.05.min_element/main.cpp, ex.06.std-algo/main.cpp, ex.08.io-hdf5/main.cpp, ex.09.view-1dim/main.cpp, ex.10.radixsort/main.cpp, ex.11.halo-stencil/main.cpp, and ex.11.simple-stencil/main.cpp.

Definition at line 89 of file Array.h.

Member Typedef Documentation

pattern_type

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

typedef PatternType dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::pattern_type

Public types as required by dash container concept.

The type of the pattern used to distribute array elements to units

Definition at line 701 of file Array.h.

value_type

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

typedef ElementType dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::value_type

Public types as required by iterator concept.

Definition at line 658 of file Array.h.

Constructor & Destructor Documentation

Array() [1/8]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

constexpr dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::Array ( Team &  team = dash::Team::Null() )

inlineexplicit

Default constructor, for delayed allocation.

Sets the associated team to DART_TEAM_NULL for global array instances that are declared before dash::Init().

Definition at line 770 of file Array.h.

    : local(this)
    , async(this)
    , m_team(&team)
    , m_pattern(SizeSpec_t(0), distribution_spec(dash::BLOCKED), team)
  {
    DASH_LOG_TRACE("Array() >", "finished default constructor");
  }

Array() [2/8]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::Array ( size_type  nelem, const distribution_spec &  distribution, Team &  team = dash::Team::All()  )

inline

Constructor, specifies the array's global capacity and distribution.

Definition at line 782 of file Array.h.

    : local(this)
    , async(this)
    , m_team(&team)
    , m_pattern(SizeSpec_t(nelem), distribution, team)
  {
    DASH_LOG_TRACE("Array(nglobal,dist,team)()", "size:", nelem);
    allocate(m_pattern);
    DASH_LOG_TRACE("Array(nglobal,dist,team) >");
  }

Array() [3/8]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::Array ( size_type  nelem, Team &  team = dash::Team::All()  )

inlineexplicit

Delegating constructor, specifies the array's global capacity.

Definition at line 799 of file Array.h.

    : Array(nelem, dash::BLOCKED, team)
  {
    DASH_LOG_TRACE(
        "Array(nglobal,team) >", "finished delegating constructor");
  }

Array() [4/8]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::Array ( size_type  nelem, std::initializer_list< value_type >  local_elements, const distribution_spec &  distribution, Team &  team = dash::Team::All()  )

inline

Constructor, specifies the array's global capacity, values of local elements and distribution.

Definition at line 810 of file Array.h.

    : local(this)
    , async(this)
    , m_team(&team)
    , m_pattern(SizeSpec_t(nelem), distribution, team)
    , m_globmem(*m_team)
    , m_allocator(&m_globmem)
    , m_myid(team.myid())
  {
    DASH_LOG_TRACE("Array(nglobal,lvals,dist,team)()",
                   "size:",   nelem,
                   "nlocal:", local_elements.size());
    allocate(local_elements);
    DASH_LOG_TRACE("Array(nglobal,lvals,dist,team) >");
  }

Array() [5/8]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::Array ( size_type  nelem, std::initializer_list< value_type >  local_elements, Team &  team = dash::Team::All()  )

inline

Delegating constructor, specifies the array's global capacity and values of local elements.

Definition at line 834 of file Array.h.

  : Array(nelem, local_elements, dash::BLOCKED, team)
  {
    DASH_LOG_TRACE("Array(nglobal,lvals,team) >",
                   "finished delegating constructor");
  }

Array() [6/8]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::Array ( const PatternType &  pattern )

inlineexplicit

Constructor, specifies distribution pattern explicitly.

Definition at line 848 of file Array.h.

  : local(this),
    async(this),
    m_team(&pattern.team()),
    m_pattern(pattern),
    m_myid(m_team->myid())
  {
    DASH_LOG_TRACE("Array()", "pattern instance constructor");
    allocate(m_pattern);
  }

Array() [7/8]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::Array ( const self_t &  other )

delete

Copy constructor is deleted to prevent unintentional copies of - usually huge - distributed arrays.

To create a copy of a dash::Array instance, instantiate the copy instance explicitly and use dash::copy to clone elements.

Example:

dash::Array<int> a1(1024 * dash::size());
dash::fill(a1.begin(), a1.end(), 123);

// create copy of array a1:
dash::Array<int> a2(a1.size());
dash::copy(a1.begin(), a1.end(), a2.begin());

Array() [8/8]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::Array ( self_t &&  other )

inlinenoexcept

Move construction is supported for the container with the following limitations:

The pattern has to be movable or copyable The underlying memory does not have to be movable (it might).

Definition at line 887 of file Array.h.

    : local(this)
    , async(this)
    , m_team(other.m_team)
    , m_pattern(std::move(other.m_pattern))
    , m_globmem(std::move(other.m_globmem))
    , m_allocator(&m_globmem)
    , m_data(
          other.m_data.release(),
          typename unique_gptr_t::deleter_type{m_allocator,
                                               m_pattern.local_size()})
    , m_begin(other.m_begin)
    , m_end(other.m_end)
    , m_size(other.m_size)
    , m_lsize(other.m_lsize)
    , m_lcapacity(other.m_lcapacity)
    , m_lbegin(other.m_lbegin)
    , m_lend(other.m_lend)
    , m_myid(other.m_myid)
  {
    other.m_begin  = iterator{};
    other.m_end    = iterator{};
    other.m_lbegin = nullptr;
    other.m_lend   = nullptr;
    other.m_lsize  = 0;
    other.m_size   = 0;

    other.m_team->unregister_deallocator(&other, std::bind(&Array::deallocate, &other));

    // Register deallocator of this array instance at the team
    // instance that has been used to initialized it:
    m_team->register_deallocator(this, std::bind(&Array::deallocate, this));
  }

~Array()

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::~Array ( )

inline

Destructor, deallocates array elements.

Definition at line 1005 of file Array.h.

  {
    DASH_LOG_TRACE_VAR("Array.~Array()", this);
    deallocate();
    DASH_LOG_TRACE_VAR("Array.~Array >", this);
  }

Member Function Documentation

allocate() [1/4]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

bool dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::allocate ( size_type  nelem, dash::DistributionSpec< 1 >  distribution, dash::Team &  team = dash::Team::All()  )

inline

Delayed allocation of global memory using a one-dimensional distribution spec.

Definition at line 1319 of file Array.h.

Referenced by dash::Coevent::initialize(), and dash::List< ElementType, LocalMemorySpace >::List().

  {
    DASH_LOG_TRACE_VAR("Array.allocate(nlocal,ds,team)", nelem);
    DASH_LOG_TRACE_VAR("Array.allocate", m_team->dart_id());
    DASH_LOG_TRACE_VAR("Array.allocate", team.dart_id());
    // Check requested capacity:
    if (nelem == 0) {
      DASH_LOG_WARN("Array.allocate", "allocating dash::Array with size 0");
    }
    if (m_team == nullptr || *m_team == dash::Team::Null()) {
      DASH_LOG_TRACE("Array.allocate",
                     "initializing with specified team -",
                     "team size:", team.size());
      m_team    = &team;
      m_pattern = PatternType(nelem, distribution, team);
      DASH_LOG_TRACE_VAR("Array.allocate", team.dart_id());
      DASH_LOG_TRACE_VAR("Array.allocate", m_pattern.team().dart_id());
    } else {
      DASH_LOG_TRACE("Array.allocate",
                     "initializing pattern with initial team");
      m_pattern = PatternType(nelem, distribution, *m_team);
    }

    bool ret = allocate(m_pattern);
    DASH_LOG_TRACE("Array.allocate(nlocal,ds,team) >");
    return ret;
  }

allocate() [2/4]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

bool dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::allocate ( size_type  nelem, Team &  team = dash::Team::All()  )

inline

Delayed allocation of global memory using the default blocked distribution spec.

Definition at line 1355 of file Array.h.

  {
    return allocate(nelem, dash::BLOCKED, team);
  }

allocate() [3/4]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

bool dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::allocate ( size_type  nelem, std::initializer_list< value_type >  local_elements, dash::DistributionSpec< 1 >  distribution, dash::Team &  team = dash::Team::All()  )

inline

Delayed allocation of global memory using a one-dimensional distribution spec and initializing values.

Definition at line 1367 of file Array.h.

  {
    DASH_LOG_TRACE_VAR("Array.allocate(lvals,ds,team)",
                       local_elements.size());
    DASH_LOG_TRACE_VAR("Array.allocate", m_team->dart_id());
    DASH_LOG_TRACE_VAR("Array.allocate", team.dart_id());
    // Check requested capacity:
    if (nelem == 0) {
      DASH_THROW(
        dash::exception::InvalidArgument,
        "Tried to allocate dash::Array with size 0");
    }
    if (m_team == nullptr || *m_team == dash::Team::Null()) {
      DASH_LOG_TRACE("Array.allocate",
                     "initializing pattern with Team::All()");
      m_team    = &team;
      m_pattern = PatternType(nelem, distribution, team);
      DASH_LOG_TRACE_VAR("Array.allocate", team.dart_id());
      DASH_LOG_TRACE_VAR("Array.allocate", m_pattern.team().dart_id());
    } else {
      DASH_LOG_TRACE("Array.allocate",
                     "initializing pattern with initial team");
      m_pattern = PatternType(nelem, distribution, *m_team);
    }
    bool ret = allocate(local_elements);
    DASH_LOG_TRACE("Array.allocate(lvals,ds,team) >");
    return ret;
  }

allocate() [4/4]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

bool dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::allocate ( const PatternType &  pattern )

inline

Delayed allocation of global memory using the specified pattern.

Definition at line 1522 of file Array.h.

  {
    DASH_LOG_TRACE("< Array.allocate", "finished");
    if (&m_pattern != &pattern) {
      DASH_LOG_TRACE("Array.allocate()", "using specified pattern");
      m_pattern = pattern;
    }

    do_allocate();

    // Local iterators:
    auto soon_to_be_lbegin = m_data.get();
    soon_to_be_lbegin.set_unit(m_myid);
    m_lbegin = soon_to_be_lbegin.local();
    // More efficient than using m_globmem->lend as this a second mapping
    // of the local memory segment:
    m_lend = std::next(m_lbegin, m_lsize);

    // We do no construct the elements to prevent NUMA effects
    // construct_at_end(m_lsize);

    // Register deallocator of this array instance at the team
    // instance that has been used to initialized it:
    m_team->register_deallocator(this, std::bind(&Array::deallocate, this));
    // Assure all units are synchronized after allocation, otherwise
    // other units might start working on the array before allocation
    // completed at all units:
    DASH_LOG_TRACE("Array.allocate", "waiting for allocation of all units");
    m_team->barrier();
    DASH_LOG_TRACE("Array.allocate >", "finished");
    return true;
  }

at() [1/2]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

reference dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::at ( size_type  global_pos )

inline

Random access assignment operator, range-checked.

See also

operator[]

Returns

A global reference to the element in the array at the given index.

Parameters

global_pos

The position of the element to return

Examples:

ex.11.halo-stencil/main.cpp, and ex.11.simple-stencil/main.cpp.

Definition at line 1132 of file Array.h.

Referenced by dash::Coevent::wait().

  {
    if (global_pos >= size())  {
      DASH_THROW(
          dash::exception::OutOfRange,
          "Position " << global_pos
          << " is out of range " << size()
          << " in Array.at()" );
    }
    return m_begin[global_pos];
  }

at() [2/2]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

const_reference dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::at ( size_type  global_pos ) const

inline

Random access operator, range-checked.

See also

operator[]

Returns

A global reference to the element in the array at the given index.

Parameters

global_pos

The position of the element to return

Definition at line 1154 of file Array.h.

  {
    if (global_pos >= size())  {
      DASH_THROW(
          dash::exception::OutOfRange,
          "Position " << global_pos
          << " is out of range " << size()
          << " in Array.at()" );
    }
    return m_begin[global_pos];
  }

barrier()

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

void dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::barrier ( ) const

inline

Establish a barrier for all units operating on the array, publishing all changes to all units.

Examples:

ex.09.view-1dim/main.cpp.

Definition at line 1254 of file Array.h.

Referenced by dash::Coevent::initialize(), and dash::SharedCounter< ValueType >::SharedCounter().

  {
    DASH_LOG_TRACE_VAR("Array.barrier()", m_team);
    flush();
    if (m_team && *m_team != dash::Team::Null()) {
      m_team->barrier();
    }
    DASH_LOG_TRACE("Array.barrier >", "passed barrier");
  }

begin() [1/2]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

iterator dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::begin ( )

inlinenoexcept

Global pointer to the beginning of the array.

Examples:

ex.08.io-hdf5/main.cpp, ex.11.halo-stencil/main.cpp, and ex.11.simple-stencil/main.cpp.

Definition at line 1040 of file Array.h.

Referenced by dash::Coevent::Coevent(), dash::Coevent::initialize(), dash::LocalArrayRef< value_type, dash::default_index_t, BlockPattern< 1, ROW_MAJOR, dash::default_index_t >, HostSpace >::pattern(), and dash::Coevent::wait().

  {
    return m_begin;
  }

begin() [2/2]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

constexpr const_iterator dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::begin ( ) const

inlinenoexcept

Global pointer to the beginning of the array.

Definition at line 1048 of file Array.h.

  {
    return const_iterator(
        const_cast<memory_type *>(&m_globmem), m_pattern, m_begin.pos());
  }

block()

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

constexpr const view_type dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::block ( index_type  block_gindex ) const

inline

View at block at given global block offset.

Definition at line 1015 of file Array.h.

  {
    return View(this, ViewSpec<1>(pattern().block(block_gindex)));
  }

capacity()

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

constexpr size_type dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::capacity ( ) const

inlinenoexcept

The number of elements that can be held in currently allocated storage of the array.

Returns

The number of elements in the array.

Definition at line 1184 of file Array.h.

  {
    return m_size;
  }

data()

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

constexpr const_pointer dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::data ( ) const

inlinenoexcept

Global const pointer to the beginning of the array.

Definition at line 1032 of file Array.h.

  {
    return const_pointer(m_data.get());
  }

empty()

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

constexpr bool dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::empty ( ) const

inlinenoexcept

Checks whether the array is empty.

Returns

True if size() is 0, otherwise false

Definition at line 1227 of file Array.h.

  {
    return size() == 0;
  }

end() [1/2]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

iterator dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::end ( )

inlinenoexcept

Global pointer to the end of the array.

Examples:

ex.08.io-hdf5/main.cpp, ex.11.halo-stencil/main.cpp, and ex.11.simple-stencil/main.cpp.

Definition at line 1057 of file Array.h.

Referenced by dash::Coevent::Coevent(), and dash::Coevent::initialize().

                          {
    return m_end;
  }

end() [2/2]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

constexpr const_iterator dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::end ( ) const

inlinenoexcept

Global pointer to the end of the array.

Definition at line 1064 of file Array.h.

  {
    return const_iterator(
        const_cast<memory_type *>(&m_globmem), m_pattern, m_end.pos());
  }

flush() [1/2]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

void dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::flush ( ) const

inline

Complete all outstanding non-blocking operations to all units on the array's underlying global memory.

Definition at line 1268 of file Array.h.

Referenced by dash::LocalArrayRef< value_type, dash::default_index_t, BlockPattern< 1, ROW_MAJOR, dash::default_index_t >, HostSpace >::pattern().

                            {
    //if (m_globmem && m_begin != m_end) {
    if (m_data) {
      //If we have some allocated memory -> flush it
      m_globmem.flush(m_data.get());
    }
  }

flush() [2/2]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

void dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::flush ( dash::team_unit_t  target ) const

inline

Complete all outstanding non-blocking operations to the specified unit on the array's underlying global memory.

Definition at line 1280 of file Array.h.

                                                  {
    if (m_data) {
      m_globmem.flush(m_data.get(), target);
    }
  }

flush_local() [1/2]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

void dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::flush_local ( ) const

inline

Locally complete all outstanding non-blocking operations to all units on the array's underlying global memory.

Definition at line 1290 of file Array.h.

Referenced by dash::LocalArrayRef< value_type, dash::default_index_t, BlockPattern< 1, ROW_MAJOR, dash::default_index_t >, HostSpace >::pattern().

                                  {
    if (m_data) {
      m_globmem.flush_local(m_data.get());
    }
  }

flush_local() [2/2]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

void dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::flush_local ( dash::team_unit_t  target ) const

inline

Locally complete all outstanding non-blocking operations to the specified unit on the array's underlying global memory.

Definition at line 1301 of file Array.h.

                                                        {
    if (m_data) {
      m_globmem.flush_local(m_data.get(), target);
    }
  }

globmem()

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

constexpr const memory_type& dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::globmem ( ) const

inlinenoexcept

The instance of GlobStaticMem used by this iterator to resolve addresses in global memory.

Definition at line 1024 of file Array.h.

  {
    return m_globmem;
  }

is_local()

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

constexpr bool dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::is_local ( index_type  global_index ) const

inline

Checks whether the given global index is local to the calling unit.

Returns

True if the array element referenced by the index is held in the calling unit's local memory

Parameters

global_index

A global array index

Definition at line 1243 of file Array.h.

  {
    return m_pattern.is_local(global_index, m_myid);
  }

lbegin() [1/2]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

constexpr const ElementType* dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::lbegin ( ) const

inlinenoexcept

Native pointer to the first local element in the array.

Examples:

ex.11.simple-stencil/main.cpp.

Definition at line 1073 of file Array.h.

                                                        {
    return m_lbegin;
  }

lbegin() [2/2]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

ElementType* dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::lbegin ( )

inlinenoexcept

Native pointer to the first local element in the array.

Definition at line 1080 of file Array.h.

                                  {
    return m_lbegin;
  }

lcapacity()

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

constexpr size_type dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::lcapacity ( ) const

inlinenoexcept

The capacity of the local part of the array.

Returns

The number of allocated elements in the array that are local to the calling unit.

Definition at line 1217 of file Array.h.

  {
    return m_lcapacity;
  }

lend() [1/2]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

constexpr const ElementType* dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::lend ( ) const

inlinenoexcept

Native pointer to the end of the array.

Definition at line 1087 of file Array.h.

                                                      {
    return m_lend;
  }

lend() [2/2]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

ElementType* dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::lend ( )

inlinenoexcept

Native pointer to the end of the array.

Definition at line 1094 of file Array.h.

                                {
    return m_lend;
  }

lsize()

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

constexpr size_type dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::lsize ( ) const

inlinenoexcept

The number of elements in the local part of the array.

Returns

The number of elements in the array that are local to the calling unit.

Definition at line 1206 of file Array.h.

  {
    return m_lsize;
  }

operator=() [1/2]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

self_t& dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::operator= ( const self_t &  rhs )

delete

Assignment operator is deleted to prevent unintentional copies of.

• usually huge - distributed arrays.

To create a copy of a dash::Array instance, instantiate the copy instance explicitly and use dash::copy to clone elements.

Example:

dash::Array<int> a1(1024 * dash::size());
dash::fill(a1.begin(), a1.end(), 123);

// create copy of array a1:
dash::Array<int> a2(a1.size());
dash::copy(a1.begin(), a1.end(), a2.begin());

operator=() [2/2]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

self_t& dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::operator= ( self_t &&  other )

inline

Move assignment is supported for the container with the following limitations:

The pattern has to be movable or copyable The underlying memory does not have to be movable (it might).

Definition at line 949 of file Array.h.

                                      {
    if (this == &other) {
      return *this;
    }

    m_pattern = std::move(other.m_pattern);

    DASH_ASSERT_EQ(
        m_allocator.resource(),
        &m_globmem,
        "invalid state in move assignment");

    // a) reset own data
    if (m_data) {
      destruct_at_end(m_lbegin);
    }
    m_data.reset();
    // b) swap memory resources
    m_globmem = std::move(other.m_globmem);
    // c) move the unique_gptr from other into this
    unique_gptr_t __tmp{other.m_data.release(),
                        typename unique_gptr_t::deleter_type{
                            m_allocator, m_pattern.local_size()}};
    m_data = std::move(__tmp);


    //TODO rko: we have to provide a proper dash::swap for iterators;
    this->m_begin = iterator{&m_globmem, m_pattern, other.m_begin.pos()};
    this->m_end = iterator{&m_globmem, m_pattern, other.m_end.pos()};

    this->m_lbegin    = other.m_lbegin;
    this->m_lcapacity = other.m_lcapacity;
    this->m_lend      = other.m_lend;
    this->m_lsize     = other.m_lsize;
    this->m_myid      = other.m_myid;
    this->m_size      = other.m_size;
    this->m_team      = other.m_team;

    other.m_begin = iterator{};
    other.m_end   = iterator{};

    other.m_lbegin  = nullptr;
    other.m_lend    = nullptr;
    other.m_lsize   = 0;
    other.m_size    = 0;

    other.m_team->unregister_deallocator(&other, std::bind(&Array::deallocate, &other));

    m_team->register_deallocator(this, std::bind(&Array::deallocate, this));

    return *this;
  }

operator[]() [1/2]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

reference dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::operator[] ( size_type  global_index )

inline

Subscript assignment operator, not range-checked.

Returns

A global reference to the element in the array at the given index.

Parameters

global_index

The position of the element to return

Definition at line 1104 of file Array.h.

  {
    return m_begin[global_index];
  }

operator[]() [2/2]

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

constexpr const_reference dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::operator[] ( size_type  global_index ) const

inline

Subscript operator, not range-checked.

Returns

A global reference to the element in the array at the given index.

Parameters

global_index

The position of the element to return

Definition at line 1117 of file Array.h.

  {
    return m_begin[global_index];
  }

pattern()

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

constexpr const PatternType& dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::pattern ( ) const

inlinenoexcept

The pattern used to distribute array elements to units.

Examples:

ex.08.io-hdf5/main.cpp, ex.09.view-1dim/main.cpp, and ex.11.simple-stencil/main.cpp.

Definition at line 1310 of file Array.h.

Referenced by dash::LocalArrayRef< value_type, dash::default_index_t, BlockPattern< 1, ROW_MAJOR, dash::default_index_t >, HostSpace >::pattern().

  {
    return m_pattern;
  }

size()

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

constexpr size_type dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::size ( ) const

inlinenoexcept

The size of the array.

Returns

The number of elements in the array.

Examples:

ex.11.halo-stencil/main.cpp.

Definition at line 1173 of file Array.h.

Referenced by dash::LocalArrayRef< value_type, dash::default_index_t, BlockPattern< 1, ROW_MAJOR, dash::default_index_t >, HostSpace >::pattern().

  {
    return m_size;
  }

team()

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

constexpr Team& dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::team ( ) const

inlinenoexcept

The team containing all units accessing this array.

Returns

The instance of Team that this array has been instantiated with

Definition at line 1195 of file Array.h.

  {
    return *m_team;
  }

Member Data Documentation

async

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

async_type dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::async

Proxy object, provides non-blocking operations on array.

Definition at line 734 of file Array.h.

local

template<typename ElementType, typename IndexType = dash::default_index_t, class PatternType = BlockPattern<1, ROW_MAJOR, IndexType>, typename LocalMemSpaceT = HostSpace>

local_type dash::Array< ElementType, IndexType, PatternType, LocalMemSpaceT >::local

Local proxy object, allows use in range-based for loops.

Examples:

ex.09.view-1dim/main.cpp.

Definition at line 732 of file Array.h.

Referenced by dash::List< ElementType, LocalMemorySpace >::deallocate(), dash::find_if(), dash::SharedCounter< ValueType >::get(), dash::GlobHeapMem< ElementType, LocalMemorySpace, AllocationPolicy, LocalAlloc >::GlobHeapMem(), dash::GlobHeapMem< ElementType, LocalMemorySpace, AllocationPolicy, LocalAlloc >::grow(), dash::List< ElementType, LocalMemorySpace >::List(), dash::GlobHeapMem< ElementType, LocalMemorySpace, AllocationPolicy, LocalAlloc >::local_size(), dash::List< ElementType, LocalMemorySpace >::lsize(), dash::LocalListRef< ElementType, LocalMemorySpace >::push_back(), dash::SharedCounter< ValueType >::SharedCounter(), dash::GlobHeapMem< ElementType, LocalMemorySpace, AllocationPolicy, LocalAlloc >::shrink(), and dash::List< ElementType, LocalMemorySpace >::size().

---

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

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