dash::BlockPattern< 1, Arrangement, IndexType > Class Template Reference

Defines how a list of global indices is mapped to single units within a Team. More...

#include <BlockPattern1D.h>

Classes
struct	local_coords_t
struct	local_index_t

Public Types
typedef pattern_partitioning_properties< pattern_partitioning_tag::rectangular, pattern_partitioning_tag::balanced, pattern_partitioning_tag::unbalanced >	partitioning_properties
	Satisfiable properties in pattern property category Partitioning: More...
typedef pattern_mapping_properties< pattern_mapping_tag::unbalanced >	mapping_properties
	Satisfiable properties in pattern property category Mapping: More...
typedef pattern_layout_properties< pattern_layout_tag::canonical, pattern_layout_tag::linear >	layout_properties
	Satisfiable properties in pattern property category Layout: More...
typedef IndexType	index_type
typedef SizeType	size_type
typedef ViewSpec_t	viewspec_type

Public Member Functions
template<typename ... Args>
	BlockPattern (SizeType arg, Args &&... args)
	Constructor, initializes a pattern from an argument list consisting of the pattern size (extent, number of elements) followed by an optional distribution type. More...
	BlockPattern (const SizeSpec_t sizespec, const DistributionSpec_t dist, const TeamSpec_t teamspec, dash::Team &team=dash::Team::All())
	Constructor, initializes a pattern from explicit instances of SizeSpec, DistributionSpec, TeamSpec and a Team. More...
	BlockPattern (const SizeSpec_t sizespec, const DistributionSpec_t dist=DistributionSpec_t(), Team &team=dash::Team::All())
	Constructor, initializes a pattern from explicit instances of SizeSpec, DistributionSpec and a Team. More...
constexpr	BlockPattern (self_t &&other)=default
	Move constructor. More...
constexpr	BlockPattern (const self_t &other)=default
	Copy constructor. More...
constexpr	BlockPattern (self_t &other)
	Copy constructor using non-const lvalue reference parameter. More...
self_t &	operator= (self_t &&other)=default
	Move-assignment operator. More...
self_t &	operator= (const self_t &other)=default
	Assignment operator. More...
constexpr bool	operator== (const self_t &other) const
	Equality comparison operator. More...
constexpr bool	operator!= (const self_t &other) const
	Inquality comparison operator. More...
constexpr IndexType	lbegin () const
	Resolves the global index of the first local element in the pattern. More...
constexpr IndexType	lend () const
	Resolves the global index past the last local element in the pattern. More...
constexpr team_unit_t	unit_at (const std::array< IndexType, NumDimensions > &coords, const ViewSpec_t &viewspec) const
	unit_at More...
constexpr team_unit_t	unit_at (const std::array< IndexType, NumDimensions > &coords) const
	Convert given coordinate in pattern to its assigned unit id. More...
constexpr team_unit_t	unit_at (IndexType global_pos, const ViewSpec_t &viewspec) const
	Convert given global linear index to its assigned unit id. More...
constexpr team_unit_t	unit_at (IndexType global_pos) const
	Convert given global linear index to its assigned unit id. More...
IndexType	extent (dim_t dim) const
	extent More...
template<dim_t dim = 0>
constexpr IndexType	extent () const
	The number of elements in this pattern in the given dimension. More...
IndexType	local_extent (dim_t dim) const
	The actual number of elements in this pattern that are local to the calling unit in the given dimension. More...
template<dim_t dim = 0>
constexpr IndexType	local_extent () const
	The actual number of elements in this pattern that are local to the calling unit in the given dimension. More...
constexpr std::array< SizeType, NumDimensions >	local_extents (team_unit_t unit) const
	The actual number of elements in this pattern that are local to the given unit, by dimension. More...
constexpr std::array< SizeType, NumDimensions >	local_extents () const
	The actual number of elements in this pattern that are local to the active unit, by dimension. More...
constexpr IndexType	local_at (const std::array< IndexType, NumDimensions > &local_coords, const ViewSpec_t &viewspec) const
	local More...
constexpr IndexType	local_at (const std::array< IndexType, NumDimensions > &local_coords) const
	Convert given local coordinates to linear local offset (index). More...
constexpr local_coords_t	local (const std::array< IndexType, NumDimensions > &global_coords) const
	Converts global coordinates to their associated unit and its respective local coordinates. More...
constexpr local_index_t	local (IndexType g_index) const
	Converts global index to its associated unit and respective local index. More...
constexpr std::array< IndexType, NumDimensions >	local_coords (const std::array< IndexType, NumDimensions > &global_coords) const noexcept
	Converts global coordinates to their associated unit's respective local coordinates. More...
constexpr local_index_t	local_index (const std::array< IndexType, NumDimensions > &g_coords) const
	Resolves the unit and the local index from global coordinates. More...
constexpr std::array< IndexType, NumDimensions >	global (team_unit_t unit, const std::array< IndexType, NumDimensions > &local_coords) const
	global More...
constexpr std::array< IndexType, NumDimensions >	global (const std::array< IndexType, NumDimensions > &l_coords) const
	Converts local coordinates of active unit to global coordinates. More...
constexpr IndexType	global (IndexType l_index) const
	Resolve an element's linear global index from the calling unit's local index of that element. More...
constexpr IndexType	global_index (team_unit_t unit, const std::array< IndexType, NumDimensions > &l_coords) const
	Resolve an element's linear global index from a given unit's local coordinates of that element. More...
constexpr IndexType	global_at (const std::array< IndexType, NumDimensions > &global_coords, const ViewSpec_t &viewspec) const
	Convert given global coordinates and viewspec to linear global offset (index). More...
constexpr IndexType	global_at (const std::array< IndexType, NumDimensions > &global_coords) const
	Convert given global coordinates to linear global offset (index). More...
constexpr IndexType	at (const std::array< IndexType, NumDimensions > &g_coords) const
	at More...
constexpr IndexType	at (const std::array< IndexType, 1 > &g_coords, const ViewSpec_t &viewspec) const
	Global coordinates and viewspec to local index. More...
template<typename ... Values>
constexpr IndexType	at (IndexType value, Values ... values) const
	Global coordinates to local index. More...
constexpr bool	has_local_elements (dim_t dim, IndexType dim_offset, team_unit_t unit) const
	is_local More...
constexpr bool	is_local (IndexType index, team_unit_t unit) const
	Whether the given global index is local to the specified unit. More...
constexpr bool	is_local (IndexType index) const
	Whether the given global index is local to the unit that created this pattern instance. More...
constexpr BlockSpec_t	blockspec () const
	block More...
constexpr BlockSpec_t	local_blockspec () const
	Cartesian arrangement of local pattern blocks. More...
constexpr index_type	block_at (const std::array< index_type, NumDimensions > &g_coords) const
	Gobal index of block at given global coordinates. More...
constexpr local_index_t	local_block_at (const std::array< index_type, NumDimensions > &g_coords) const
	Local index of block at given global coordinates. More...
constexpr ViewSpec_t	block (index_type g_block_index) const
	View spec (offset and extents) of block at global linear block index in cartesian element space. More...
constexpr ViewSpec_t	local_block (index_type l_block_index) const
	View spec (offset and extents) of block at local linear block index in global cartesian element space. More...
ViewSpec_t	local_block_local (index_type l_block_index) const
	View spec (offset and extents) of block at local linear block index in local cartesian element space. More...
constexpr SizeType	blocksize (dim_t dimension) const
	Maximum number of elements in a single block in the given dimension. More...
constexpr SizeType	max_blocksize () const
	Maximum number of elements in a single block in all dimensions. More...
constexpr SizeType	local_capacity () const
	Maximum number of elements assigned to a single unit in total, equivalent to the local capacity of every unit in this pattern. More...
constexpr SizeType	local_size (team_unit_t unit) const
	The actual number of elements in this pattern that are local to the specified unit in total. More...
constexpr SizeType	local_size () const noexcept
	The actual number of elements in this pattern that are local to the calling unit in total. More...
constexpr IndexType	num_units () const noexcept
	The number of units to which this pattern's elements are mapped. More...
constexpr IndexType	capacity () const noexcept
	The maximum number of elements arranged in this pattern. More...
constexpr IndexType	size () const noexcept
	The number of elements arranged in this pattern. More...
constexpr dash::Team &	team () const noexcept
	The Team containing the units to which this pattern's elements are mapped. More...
constexpr const DistributionSpec_t &	distspec () const noexcept
	Distribution specification of this pattern. More...
constexpr SizeSpec_t	sizespec () const
	Size specification of the index space mapped by this pattern. More...
constexpr const std::array< SizeType, NumDimensions >	extents () const
	Size specification of the index space mapped by this pattern. More...
constexpr const TeamSpec_t &	teamspec () const
	Cartesian arrangement of the Team containing the units to which this pattern's elements are mapped. More...
constexpr std::array< IndexType, NumDimensions >	coords (IndexType index) const
	Convert given global linear offset (index) to global cartesian coordinates. More...
constexpr std::array< IndexType, NumDimensions >	coords (IndexType index, const ViewSpec_t &viewspec) const
	Convert given global linear offset (index) to global cartesian coordinates using viewspec. More...
constexpr SizeType	underfilled_blocksize (dim_t dimension) const
	Number of elements missing in the overflow block of given dimension compared to the regular blocksize (. More...

Static Public Member Functions
static constexpr MemArrange	memory_order ()
	Memory order followed by the pattern. More...
static constexpr dim_t	ndim ()
	Number of dimensions of the cartesian space partitioned by the pattern. More...

Static Public Attributes
static constexpr const char *	PatternName = "BlockPattern1D"

Detailed Description

template<MemArrange Arrangement, typename IndexType>
class dash::BlockPattern< 1, Arrangement, IndexType >

Defines how a list of global indices is mapped to single units within a Team.

Implemented concept:

Pattern Concept

Definition at line 35 of file BlockPattern1D.h.

Member Typedef Documentation

layout_properties

template<MemArrange Arrangement, typename IndexType >

typedef pattern_layout_properties< pattern_layout_tag::canonical, pattern_layout_tag::linear > dash::BlockPattern< 1, Arrangement, IndexType >::layout_properties

Satisfiable properties in pattern property category Layout:

Definition at line 65 of file BlockPattern1D.h.

mapping_properties

template<MemArrange Arrangement, typename IndexType >

typedef pattern_mapping_properties< pattern_mapping_tag::unbalanced > dash::BlockPattern< 1, Arrangement, IndexType >::mapping_properties

Satisfiable properties in pattern property category Mapping:

Definition at line 57 of file BlockPattern1D.h.

partitioning_properties

template<MemArrange Arrangement, typename IndexType >

typedef pattern_partitioning_properties< pattern_partitioning_tag::rectangular, pattern_partitioning_tag::balanced, pattern_partitioning_tag::unbalanced > dash::BlockPattern< 1, Arrangement, IndexType >::partitioning_properties

Satisfiable properties in pattern property category Partitioning:

Definition at line 52 of file BlockPattern1D.h.

Constructor & Destructor Documentation

BlockPattern() [1/6]

template<MemArrange Arrangement, typename IndexType >

template<typename ... Args>

dash::BlockPattern< 1, Arrangement, IndexType >::BlockPattern ( SizeType  arg, Args &&...  args  )

inline

Constructor, initializes a pattern from an argument list consisting of the pattern size (extent, number of elements) followed by an optional distribution type.

Examples:

// 500 elements with blocked distribution:
Pattern p1(500, BLOCKED);
// Same as
Pattern p1(SizeSpec<1>(500),
           DistributionSpec<2>(BLOCKED),
           TeamSpec<1>(dash::Team::All()),
           // The team containing the units to which the pattern
           // maps the global indices. Defaults to all all units:
           dash::Team::All());

Parameters

arg	Argument list consisting of the pattern size (extent, number of elements) in every dimension followed by optional distribution types.
args	Argument list consisting of the pattern size (extent, number of elements) in every dimension followed by optional distribution types.

Definition at line 158 of file BlockPattern1D.h.

  : BlockPattern(PatternArguments_t(arg, args...))
  { }

BlockPattern() [2/6]

template<MemArrange Arrangement, typename IndexType >

dash::BlockPattern< 1, Arrangement, IndexType >::BlockPattern ( const SizeSpec_t  sizespec, const DistributionSpec_t  dist, const TeamSpec_t  teamspec, dash::Team &  team = dash::Team::All()  )

inline

Constructor, initializes a pattern from explicit instances of SizeSpec, DistributionSpec, TeamSpec and a Team.

Examples:

// 500 elements with blocked distribution:
Pattern p1(SizeSpec<1>(500),
           DistributionSpec<1>(BLOCKED),
           TeamSpec<1>(dash::Team::All()),
           // The team containing the units to which the pattern
           // maps the global indices. Defaults to all all units:
           dash::Team::All());
// Same as
Pattern p1(500, BLOCKED);
// Same as
Pattern p1(SizeSpec<1>(500),
           DistributionSpec<1>(BLOCKED));
// Same as
Pattern p1(SizeSpec<1>(500),
           DistributionSpec<1>(BLOCKED),
           TeamSpec<1>(dash::Team::All()));

Parameters

sizespec	Pattern size (extent, number of elements) in every dimension
dist	Distribution type (BLOCKED, CYCLIC, BLOCKCYCLIC or NONE).
teamspec	Cartesian arrangement of units within the team
team	Team containing units to which this pattern maps its elements

Definition at line 195 of file BlockPattern1D.h.

References dash::Team::size(), and dash::BlockPattern< NumDimensions, Arrangement, IndexType >::team().

  : _size(sizespec.size()),
    _memory_layout(std::array<SizeType, 1> {{ _size }}),
    _distspec(dist),
    _team(&team),
    _teamspec(
      teamspec,
      _distspec,
      *_team),
    _nunits(_team->size()),
    _blocksize(initialize_blocksize(
        _size,
        _distspec,
        _nunits)),
    _nblocks(initialize_num_blocks(
        _size,
        _blocksize,
        _nunits)),
    _local_size(
        initialize_local_extent(_team->myid())),
    _local_memory_layout(std::array<SizeType, 1> {{ _local_size }}),
    _nlblocks(initialize_num_local_blocks(
        _blocksize,
        _local_size)),
    _local_capacity(initialize_local_capacity()),
    _lbegin_lend(initialize_local_range(_local_size))
  { }

BlockPattern() [3/6]

template<MemArrange Arrangement, typename IndexType >

dash::BlockPattern< 1, Arrangement, IndexType >::BlockPattern ( const SizeSpec_t  sizespec, const DistributionSpec_t  dist = DistributionSpec_t(), Team &  team = dash::Team::All()  )

inline

Constructor, initializes a pattern from explicit instances of SizeSpec, DistributionSpec and a Team.

Examples:

// 500 elements with blocked distribution:
Pattern p1(SizeSpec<1>(500),
           DistributionSpec<1>(BLOCKED),
           TeamSpec<1>(dash::Team::All()),
           // The team containing the units to which the pattern
           // maps the global indices. Defaults to all all units:
           dash::Team::All());
// Same as
Pattern p1(500, BLOCKED);
// Same as
Pattern p1(SizeSpec<1>(500),
           DistributionSpec<1>(BLOCKED));
// Same as
Pattern p1(SizeSpec<1>(500),
           DistributionSpec<1>(BLOCKED),
           TeamSpec<1>(dash::Team::All()));

Parameters

sizespec	Pattern size (extent, number of elements) in every dimension
dist	Distribution type (BLOCKED, CYCLIC, BLOCKCYCLIC, TILE or NONE). Defaults to BLOCKED.
team	Team containing units to which this pattern maps its elements

Definition at line 256 of file BlockPattern1D.h.

References dash::BlockPattern< NumDimensions, Arrangement, IndexType >::BlockPattern(), dash::Team::size(), and dash::BlockPattern< NumDimensions, Arrangement, IndexType >::team().

  : _size(sizespec.size()),
    _memory_layout(std::array<SizeType, 1> {{ _size }}),
    _distspec(dist),
    _team(&team),
    _teamspec(_distspec, *_team),
    _nunits(_team->size()),
    _blocksize(initialize_blocksize(
        _size,
        _distspec,
        _nunits)),
    _nblocks(initialize_num_blocks(
        _size,
        _blocksize,
        _nunits)),
    _local_size(
        initialize_local_extent(_team->myid())),
    _local_memory_layout(std::array<SizeType, 1> {{ _local_size }}),
    _nlblocks(initialize_num_local_blocks(
        _blocksize,
        _local_size)),
    _local_capacity(initialize_local_capacity()),
    _lbegin_lend(initialize_local_range(_local_size))
  { }

BlockPattern() [4/6]

template<MemArrange Arrangement, typename IndexType >

constexpr dash::BlockPattern< 1, Arrangement, IndexType >::BlockPattern ( self_t &&  other )

default

Move constructor.

BlockPattern() [5/6]

template<MemArrange Arrangement, typename IndexType >

constexpr dash::BlockPattern< 1, Arrangement, IndexType >::BlockPattern ( const self_t &  other )

default

Copy constructor.

BlockPattern() [6/6]

template<MemArrange Arrangement, typename IndexType >

constexpr dash::BlockPattern< 1, Arrangement, IndexType >::BlockPattern ( self_t &  other )

inline

Copy constructor using non-const lvalue reference parameter.

Introduced so variadic constructor is not a better match for copy-construction.

Definition at line 304 of file BlockPattern1D.h.

References dash::BlockPattern< NumDimensions, Arrangement, IndexType >::operator=().

  : BlockPattern(static_cast<const self_t &>(other)) {
  }

Member Function Documentation

at() [1/3]

template<MemArrange Arrangement, typename IndexType >

constexpr IndexType dash::BlockPattern< 1, Arrangement, IndexType >::at ( const std::array< IndexType, NumDimensions > &  g_coords ) const

inline

at

Global coordinates to local index.

Convert given global coordinates in pattern to their respective linear local index.

See also

Pattern Concept

Definition at line 729 of file BlockPattern1D.h.

References dash::BlockPattern< NumDimensions, Arrangement, IndexType >::local_coords().

                                                               {
    return local_coords(g_coords)[0];
  }

at() [2/3]

template<MemArrange Arrangement, typename IndexType >

constexpr IndexType dash::BlockPattern< 1, Arrangement, IndexType >::at ( const std::array< IndexType, 1 > &  g_coords, const ViewSpec_t &  viewspec  ) const

inline

Global coordinates and viewspec to local index.

Convert given global coordinate in pattern to its linear local index.

See also

Pattern Concept

Definition at line 741 of file BlockPattern1D.h.

References dash::BlockPattern< NumDimensions, Arrangement, IndexType >::local_coords().

                                       {
    return local_coords(
             std::array<IndexType, 1> {{
               g_coords[0] + viewspec.offset(0)
             }}
           )[0];
  }

at() [3/3]

template<MemArrange Arrangement, typename IndexType >

template<typename ... Values>

constexpr IndexType dash::BlockPattern< 1, Arrangement, IndexType >::at ( IndexType  value, Values ...  values  ) const

inline

Global coordinates to local index.

Convert given coordinate in pattern to its linear local index.

See also

Pattern Concept

Definition at line 759 of file BlockPattern1D.h.

References dash::BlockPattern< NumDimensions, Arrangement, IndexType >::at().

                                                                   {
    static_assert(
      sizeof...(values) == NumDimensions-1,
      "Wrong parameter number");
    return at(std::array<IndexType, NumDimensions> {
                value, (IndexType)values...
              });
  }

block()

template<MemArrange Arrangement, typename IndexType >

constexpr ViewSpec_t dash::BlockPattern< 1, Arrangement, IndexType >::block ( index_type  g_block_index ) const

inline

View spec (offset and extents) of block at global linear block index in cartesian element space.

Parameters

g_block_index

Global block index

Definition at line 866 of file BlockPattern1D.h.

References dash::BlockPattern< NumDimensions, Arrangement, IndexType >::underfilled_blocksize().

  {
    return ViewSpec_t(
      {{ static_cast<index_type>(g_block_index * _blocksize) }},
      {{ static_cast<size_type>(
          _blocksize - ( g_block_index < _nblocks - 1
                         ? 0
                         : underfilled_blocksize(0) )
         ) }}
    );
  }

block_at()

template<MemArrange Arrangement, typename IndexType >

constexpr index_type dash::BlockPattern< 1, Arrangement, IndexType >::block_at ( const std::array< index_type, NumDimensions > &  g_coords ) const

inline

Gobal index of block at given global coordinates.

See also

Pattern Concept

Parameters

g_coords

Global coordinates of element

Definition at line 838 of file BlockPattern1D.h.

                                                                {
    return g_coords[0] / _blocksize;
  }

blocksize()

template<MemArrange Arrangement, typename IndexType >

constexpr SizeType dash::BlockPattern< 1, Arrangement, IndexType >::blocksize ( dim_t  dimension ) const

inline

Maximum number of elements in a single block in the given dimension.

Returns

The blocksize in the given dimension

See also

Pattern Concept

Parameters

dimension

The dimension in the pattern

Definition at line 929 of file BlockPattern1D.h.

                           {
    return _blocksize;
  }

blockspec()

template<MemArrange Arrangement, typename IndexType >

constexpr BlockSpec_t dash::BlockPattern< 1, Arrangement, IndexType >::blockspec ( ) const

inline

block

Cartesian arrangement of pattern blocks.

Definition at line 821 of file BlockPattern1D.h.

                                          {
    return BlockSpec_t({ _nblocks });
  }

capacity()

template<MemArrange Arrangement, typename IndexType >

constexpr IndexType dash::BlockPattern< 1, Arrangement, IndexType >::capacity ( ) const

inlinenoexcept

The maximum number of elements arranged in this pattern.

See also

Pattern Concept

Definition at line 1004 of file BlockPattern1D.h.

                                                {
    return _size;
  }

coords() [1/2]

template<MemArrange Arrangement, typename IndexType >

constexpr std::array<IndexType, NumDimensions> dash::BlockPattern< 1, Arrangement, IndexType >::coords ( IndexType  index ) const

inline

Convert given global linear offset (index) to global cartesian coordinates.

See also

Pattern Concept

Definition at line 1066 of file BlockPattern1D.h.

                           {
    return std::array<IndexType, 1> {{ index }};
  }

coords() [2/2]

template<MemArrange Arrangement, typename IndexType >

constexpr std::array<IndexType, NumDimensions> dash::BlockPattern< 1, Arrangement, IndexType >::coords ( IndexType  index, const ViewSpec_t &  viewspec  ) const

inline

Convert given global linear offset (index) to global cartesian coordinates using viewspec.

See also

Pattern Concept

Definition at line 1077 of file BlockPattern1D.h.

                                       {
    return std::array<IndexType, 1> {{ index + viewspec.offset(0) }};
  }

distspec()

template<MemArrange Arrangement, typename IndexType >

constexpr const DistributionSpec_t& dash::BlockPattern< 1, Arrangement, IndexType >::distspec ( ) const

inlinenoexcept

Distribution specification of this pattern.

Definition at line 1028 of file BlockPattern1D.h.

                                                                 {
    return _distspec;
  }

extent() [1/2]

template<MemArrange Arrangement, typename IndexType >

IndexType dash::BlockPattern< 1, Arrangement, IndexType >::extent ( dim_t  dim ) const

inline

extent

The number of elements in this pattern in the given dimension.

See also

blocksize()

local_size()

local_extent()

Pattern Concept

Definition at line 438 of file BlockPattern1D.h.

                                    {
    DASH_ASSERT_EQ(
      0, dim,
      "Wrong dimension for Pattern::local_extent. " <<
      "Expected dimension = 0, got " << dim);
    return _size;
  }

extent() [2/2]

template<MemArrange Arrangement, typename IndexType >

template<dim_t dim = 0>

constexpr IndexType dash::BlockPattern< 1, Arrangement, IndexType >::extent ( ) const

inline

The number of elements in this pattern in the given dimension.

See also

blocksize()

local_size()

local_extent()

Pattern Concept

Definition at line 456 of file BlockPattern1D.h.

                                     {
    static_assert(
      0 == dim,
      "Wrong dimension for Pattern::local_extent. "
      "Expected dimension = 0");
    return _size;
  }

extents()

template<MemArrange Arrangement, typename IndexType >

constexpr const std::array<SizeType, NumDimensions> dash::BlockPattern< 1, Arrangement, IndexType >::extents ( ) const

inline

Size specification of the index space mapped by this pattern.

See also

Pattern Concept

Definition at line 1046 of file BlockPattern1D.h.

                                                                    {
    return std::array<SizeType, 1> {{ _size }};
  }

global() [1/3]

template<MemArrange Arrangement, typename IndexType >

constexpr std::array<IndexType, NumDimensions> dash::BlockPattern< 1, Arrangement, IndexType >::global ( team_unit_t  unit, const std::array< IndexType, NumDimensions > &  local_coords  ) const

inline

global

Converts local coordinates of a given unit to global coordinates.

See also

Pattern Concept

Definition at line 634 of file BlockPattern1D.h.

                                                                   {
    return (_nunits < 2)
            ? local_coords
            : std::array<IndexType, 1> {{
                static_cast<IndexType>(
                  (( _distspec[0].local_index_to_block_coord(
                       static_cast<IndexType>(unit),
                       local_coords[0],
                       _nunits)
                   ) * _blocksize)
                  + (local_coords[0] % _blocksize)
                )
              }};
  }

global() [2/3]

template<MemArrange Arrangement, typename IndexType >

constexpr std::array<IndexType, NumDimensions> dash::BlockPattern< 1, Arrangement, IndexType >::global ( const std::array< IndexType, NumDimensions > &  l_coords ) const

inline

Converts local coordinates of active unit to global coordinates.

See also

Pattern Concept

Definition at line 656 of file BlockPattern1D.h.

References dash::BlockPattern< NumDimensions, Arrangement, IndexType >::global().

  {
    return global(_team->myid(), l_coords);
  }

global() [3/3]

template<MemArrange Arrangement, typename IndexType >

constexpr IndexType dash::BlockPattern< 1, Arrangement, IndexType >::global ( IndexType  l_index ) const

inline

Resolve an element's linear global index from the calling unit's local index of that element.

See also

at Inverse of global()

Pattern Concept

Definition at line 670 of file BlockPattern1D.h.

References dash::BlockPattern< NumDimensions, Arrangement, IndexType >::global().

  {
    return global(_team->myid(), std::array<IndexType, 1> {{ l_index }})[0];
  }

global_at() [1/2]

template<MemArrange Arrangement, typename IndexType >

constexpr IndexType dash::BlockPattern< 1, Arrangement, IndexType >::global_at ( const std::array< IndexType, NumDimensions > &  global_coords, const ViewSpec_t &  viewspec  ) const

inline

Convert given global coordinates and viewspec to linear global offset (index).

See also

Pattern Concept

Parameters

global_coords	Point in local memory
viewspec	View specification (offsets) to apply on coords

Definition at line 697 of file BlockPattern1D.h.

                                       {
    return global_coords[0] + viewspec.offset(0);
  }

global_at() [2/2]

template<MemArrange Arrangement, typename IndexType >

constexpr IndexType dash::BlockPattern< 1, Arrangement, IndexType >::global_at ( const std::array< IndexType, NumDimensions > &  global_coords ) const

inline

Convert given global coordinates to linear global offset (index).

See also

Pattern Concept

Parameters

global_coords

Point in local memory

Definition at line 710 of file BlockPattern1D.h.

                                                                    {
    return global_coords[0];
  }

global_index()

template<MemArrange Arrangement, typename IndexType >

constexpr IndexType dash::BlockPattern< 1, Arrangement, IndexType >::global_index ( team_unit_t  unit, const std::array< IndexType, NumDimensions > &  l_coords  ) const

inline

Resolve an element's linear global index from a given unit's local coordinates of that element.

See also

at

Pattern Concept

Definition at line 684 of file BlockPattern1D.h.

  {
    return global(unit, l_coords)[0];
  }

has_local_elements()

template<MemArrange Arrangement, typename IndexType >

constexpr bool dash::BlockPattern< 1, Arrangement, IndexType >::has_local_elements ( dim_t  dim, IndexType  dim_offset, team_unit_t  unit  ) const

inline

is_local

Whether there are local elements in a dimension at a given offset, e.g. in a specific row or column.

See also

Pattern Concept

Parameters

dim	Dimension to check
dim_offset	Offset in dimension
unit	DART id of the unit

Definition at line 778 of file BlockPattern1D.h.

                            {
    // Check if unit id lies in cartesian sub-space of team spec
    return _teamspec.includes_index(
              unit,
              dim,
              dim_offset);
  }

is_local() [1/2]

template<MemArrange Arrangement, typename IndexType >

constexpr bool dash::BlockPattern< 1, Arrangement, IndexType >::is_local ( IndexType  index, team_unit_t  unit  ) const

inline

Whether the given global index is local to the specified unit.

See also

Pattern Concept

Definition at line 797 of file BlockPattern1D.h.

                            {
    return unit_at(index) == unit;
  }

is_local() [2/2]

template<MemArrange Arrangement, typename IndexType >

constexpr bool dash::BlockPattern< 1, Arrangement, IndexType >::is_local ( IndexType  index ) const

inline

Whether the given global index is local to the unit that created this pattern instance.

See also

Pattern Concept

Definition at line 809 of file BlockPattern1D.h.

References dash::BlockPattern< NumDimensions, Arrangement, IndexType >::is_local(), dash::myid(), and dash::BlockPattern< NumDimensions, Arrangement, IndexType >::team().

                           {
    return is_local(index, team().myid());
  }

lbegin()

template<MemArrange Arrangement, typename IndexType >

constexpr IndexType dash::BlockPattern< 1, Arrangement, IndexType >::lbegin ( ) const

inline

Resolves the global index of the first local element in the pattern.

See also

Pattern Concept

Definition at line 357 of file BlockPattern1D.h.

                                     {
    return _lbegin_lend[0];
  }

lend()

template<MemArrange Arrangement, typename IndexType >

constexpr IndexType dash::BlockPattern< 1, Arrangement, IndexType >::lend ( ) const

inline

Resolves the global index past the last local element in the pattern.

See also

Pattern Concept

Definition at line 366 of file BlockPattern1D.h.

                                   {
    return _lbegin_lend[1];
  }

local() [1/2]

template<MemArrange Arrangement, typename IndexType >

constexpr local_coords_t dash::BlockPattern< 1, Arrangement, IndexType >::local ( const std::array< IndexType, NumDimensions > &  global_coords ) const

inline

Converts global coordinates to their associated unit and its respective local coordinates.

TODO: Unoptimized

See also

Pattern Concept

Definition at line 575 of file BlockPattern1D.h.

References dash::BlockPattern< NumDimensions, Arrangement, IndexType >::local_coords(), and dash::BlockPattern< NumDimensions, Arrangement, IndexType >::unit_at().

                                                                    {
    return local_coords_t {
             unit_at(global_coords),      // .unit
             local_coords(global_coords)  // .coords
           };
  }

local() [2/2]

template<MemArrange Arrangement, typename IndexType >

constexpr local_index_t dash::BlockPattern< 1, Arrangement, IndexType >::local ( IndexType  g_index ) const

inline

Converts global index to its associated unit and respective local index.

TODO: Unoptimized

See also

Pattern Concept

Definition at line 590 of file BlockPattern1D.h.

References dash::BlockPattern< NumDimensions, Arrangement, IndexType >::coords(), and dash::BlockPattern< NumDimensions, Arrangement, IndexType >::local_index().

                             {
    return local_index(coords(g_index));
  }

local_at() [1/2]

template<MemArrange Arrangement, typename IndexType >

constexpr IndexType dash::BlockPattern< 1, Arrangement, IndexType >::local_at ( const std::array< IndexType, NumDimensions > &  local_coords, const ViewSpec_t &  viewspec  ) const

inline

local

Convert given local coordinates and viewspec to linear local offset (index).

See also

Pattern Concept

Parameters

local_coords	Point in local memory
viewspec	View specification (offsets) to apply on coords

Definition at line 548 of file BlockPattern1D.h.

                                       {
    return local_coords[0] + viewspec.offset(0);
  }

local_at() [2/2]

template<MemArrange Arrangement, typename IndexType >

constexpr IndexType dash::BlockPattern< 1, Arrangement, IndexType >::local_at ( const std::array< IndexType, NumDimensions > &  local_coords ) const

inline

Convert given local coordinates to linear local offset (index).

See also

Pattern Concept

Parameters

local_coords

Point in local memory

Definition at line 561 of file BlockPattern1D.h.

                                                                   {
    return local_coords[0];
  }

local_block()

template<MemArrange Arrangement, typename IndexType >

constexpr ViewSpec_t dash::BlockPattern< 1, Arrangement, IndexType >::local_block ( index_type  l_block_index ) const

inline

View spec (offset and extents) of block at local linear block index in global cartesian element space.

Parameters

l_block_index

Local block index

Definition at line 884 of file BlockPattern1D.h.

References dash::BlockPattern< NumDimensions, Arrangement, IndexType >::global().

  {
    // Local block index to local block coords:
    return ViewSpec_t(
      {{ static_cast<index_type>( global(l_block_index * _blocksize) ) }},
      {{ static_cast<size_type>(
          (l_block_index == (_nlblocks - 1)
          ? (_local_size % _blocksize == 0
             ? _blocksize
             : _local_size % _blocksize )
          : _blocksize )
         ) }}
    );
  }

local_block_at()

template<MemArrange Arrangement, typename IndexType >

constexpr local_index_t dash::BlockPattern< 1, Arrangement, IndexType >::local_block_at ( const std::array< index_type, NumDimensions > &  g_coords ) const

inline

Local index of block at given global coordinates.

See also

Pattern Concept

Parameters

g_coords

Global coordinates of element

Definition at line 849 of file BlockPattern1D.h.

References dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::size().

                                                                {
    return local_index_t {
             // unit id:
             static_cast<team_unit_t>(
                (g_coords[0] / _blocksize) % _teamspec.size()),
             // local block index:
             static_cast<index_type>(
                (g_coords[0] / _blocksize) / _teamspec.size())
           };
  }

local_block_local()

template<MemArrange Arrangement, typename IndexType >

ViewSpec_t dash::BlockPattern< 1, Arrangement, IndexType >::local_block_local ( index_type  l_block_index ) const

inline

View spec (offset and extents) of block at local linear block index in local cartesian element space.

Definition at line 905 of file BlockPattern1D.h.

References dash::BlockPattern< NumDimensions, Arrangement, IndexType >::extents().

  {
    DASH_LOG_DEBUG_VAR("BlockPattern<1>.local_block_local()", l_block_index);
    index_type offset = l_block_index * _blocksize;
    std::array<index_type, NumDimensions> offsets = {{ offset }};
    std::array<size_type, NumDimensions>  extents = {{ _blocksize }};
    if(l_block_index == (_nlblocks - 1))
    {
      size_type remaining = _local_size % extents[0];
      extents[0] = (remaining == 0) ? extents[0] : remaining;
    }
    ViewSpec_t block_vs(offsets, extents);
    DASH_LOG_DEBUG_VAR("BlockPattern<1>.local_block_local >", block_vs);
    return block_vs;
  }

local_blockspec()

template<MemArrange Arrangement, typename IndexType >

constexpr BlockSpec_t dash::BlockPattern< 1, Arrangement, IndexType >::local_blockspec ( ) const

inline

Cartesian arrangement of local pattern blocks.

Definition at line 828 of file BlockPattern1D.h.

  {
    return BlockSpec_t({ _nlblocks });
  }

local_capacity()

template<MemArrange Arrangement, typename IndexType >

constexpr SizeType dash::BlockPattern< 1, Arrangement, IndexType >::local_capacity ( ) const

inline

Maximum number of elements assigned to a single unit in total, equivalent to the local capacity of every unit in this pattern.

See also

Pattern Concept

Definition at line 953 of file BlockPattern1D.h.

  {
    return _local_capacity;
  }

local_coords()

template<MemArrange Arrangement, typename IndexType >

constexpr std::array<IndexType, NumDimensions> dash::BlockPattern< 1, Arrangement, IndexType >::local_coords ( const std::array< IndexType, NumDimensions > &  global_coords ) const

inlinenoexcept

Converts global coordinates to their associated unit's respective local coordinates.

See also

Pattern Concept

Definition at line 601 of file BlockPattern1D.h.

                   {
    return std::array<IndexType, 1> {{
             static_cast<IndexType>(
               (((global_coords[0] / _blocksize) / _nunits) * _blocksize)
               + (global_coords[0] % _blocksize)
             )
           }};
  }

local_extent() [1/2]

template<MemArrange Arrangement, typename IndexType >

IndexType dash::BlockPattern< 1, Arrangement, IndexType >::local_extent ( dim_t  dim ) const

inline

The actual number of elements in this pattern that are local to the calling unit in the given dimension.

See also

local_extents()

blocksize()

local_size()

extent()

Pattern Concept

Definition at line 475 of file BlockPattern1D.h.

                                          {
    DASH_ASSERT_EQ(
      0, dim,
      "Wrong dimension for Pattern::local_extent. " <<
      "Expected dimension = 0, got " << dim);
    return _local_size;
  }

local_extent() [2/2]

template<MemArrange Arrangement, typename IndexType >

template<dim_t dim = 0>

constexpr IndexType dash::BlockPattern< 1, Arrangement, IndexType >::local_extent ( ) const

inline

The actual number of elements in this pattern that are local to the calling unit in the given dimension.

See also

local_extents()

blocksize()

local_size()

extent()

Pattern Concept

Definition at line 495 of file BlockPattern1D.h.

                                           {
    static_assert(
      0 == dim,
      "Wrong dimension for Pattern::local_extent. "
      "Expected dimension = 0");
    return _local_size;
  }

local_extents() [1/2]

template<MemArrange Arrangement, typename IndexType >

constexpr std::array<SizeType, NumDimensions> dash::BlockPattern< 1, Arrangement, IndexType >::local_extents ( team_unit_t  unit ) const

inline

The actual number of elements in this pattern that are local to the given unit, by dimension.

See also

local_extent()

blocksize()

local_size()

extent()

Pattern Concept

Definition at line 514 of file BlockPattern1D.h.

                            {
    return std::array<SizeType, 1> {{
              unit == _team->myid()
              ? _local_size
              : initialize_local_extent(unit)
           }};
  }

local_extents() [2/2]

template<MemArrange Arrangement, typename IndexType >

constexpr std::array<SizeType, NumDimensions> dash::BlockPattern< 1, Arrangement, IndexType >::local_extents ( ) const

inline

The actual number of elements in this pattern that are local to the active unit, by dimension.

See also

local_extent()

blocksize()

local_size()

extent()

Pattern Concept

Definition at line 534 of file BlockPattern1D.h.

                                                                    {
    return std::array<SizeType, 1> {{  _local_size }};
  }

local_index()

template<MemArrange Arrangement, typename IndexType >

constexpr local_index_t dash::BlockPattern< 1, Arrangement, IndexType >::local_index ( const std::array< IndexType, NumDimensions > &  g_coords ) const

inline

Resolves the unit and the local index from global coordinates.

See also

Pattern Concept

Definition at line 617 of file BlockPattern1D.h.

References dash::BlockPattern< NumDimensions, Arrangement, IndexType >::at(), and dash::BlockPattern< NumDimensions, Arrangement, IndexType >::unit_at().

                                                               {
    return local_index_t {
             team_unit_t(unit_at(g_coords[0])),
             at(g_coords)
           };
  }

local_size() [1/2]

template<MemArrange Arrangement, typename IndexType >

constexpr SizeType dash::BlockPattern< 1, Arrangement, IndexType >::local_size ( team_unit_t  unit ) const

inline

The actual number of elements in this pattern that are local to the specified unit in total.

See also

blocksize()

local_extent()

local_capacity()

Pattern Concept

Definition at line 968 of file BlockPattern1D.h.

  {
    return (unit == _team->myid().id)
           ? _local_size
           : initialize_local_extent(unit);
  }

local_size() [2/2]

template<MemArrange Arrangement, typename IndexType >

constexpr SizeType dash::BlockPattern< 1, Arrangement, IndexType >::local_size ( ) const

inlinenoexcept

The actual number of elements in this pattern that are local to the calling unit in total.

See also

blocksize()

local_extent()

local_capacity()

Pattern Concept

Definition at line 985 of file BlockPattern1D.h.

  {
    return _local_size;
  }

max_blocksize()

template<MemArrange Arrangement, typename IndexType >

constexpr SizeType dash::BlockPattern< 1, Arrangement, IndexType >::max_blocksize ( ) const

inline

Maximum number of elements in a single block in all dimensions.

Returns

The maximum number of elements in a single block assigned to a unit.

See also

Pattern Concept

Definition at line 943 of file BlockPattern1D.h.

                                           {
    return _blocksize;
  }

memory_order()

template<MemArrange Arrangement, typename IndexType >

static constexpr MemArrange dash::BlockPattern< 1, Arrangement, IndexType >::memory_order ( )

inlinestatic

Memory order followed by the pattern.

Definition at line 1086 of file BlockPattern1D.h.

                                             {
    return Arrangement;
  }

ndim()

template<MemArrange Arrangement, typename IndexType >

static constexpr dim_t dash::BlockPattern< 1, Arrangement, IndexType >::ndim ( )

inlinestatic

Number of dimensions of the cartesian space partitioned by the pattern.

Definition at line 1093 of file BlockPattern1D.h.

                                {
    return 1;
  }

num_units()

template<MemArrange Arrangement, typename IndexType >

constexpr IndexType dash::BlockPattern< 1, Arrangement, IndexType >::num_units ( ) const

inlinenoexcept

The number of units to which this pattern's elements are mapped.

See also

Pattern Concept

Definition at line 995 of file BlockPattern1D.h.

                                                 {
    return _nunits;
  }

operator!=()

template<MemArrange Arrangement, typename IndexType >

constexpr bool dash::BlockPattern< 1, Arrangement, IndexType >::operator!= ( const self_t &  other ) const

inline

Inquality comparison operator.

Parameters

other

Pattern instance to compare for inequality

Definition at line 345 of file BlockPattern1D.h.

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

operator=() [1/2]

template<MemArrange Arrangement, typename IndexType >

self_t& dash::BlockPattern< 1, Arrangement, IndexType >::operator= ( self_t &&  other )

default

Move-assignment operator.

operator=() [2/2]

template<MemArrange Arrangement, typename IndexType >

self_t& dash::BlockPattern< 1, Arrangement, IndexType >::operator= ( const self_t &  other )

default

Assignment operator.

operator==()

template<MemArrange Arrangement, typename IndexType >

constexpr bool dash::BlockPattern< 1, Arrangement, IndexType >::operator== ( const self_t &  other ) const

inline

Equality comparison operator.

Parameters

other

Pattern instance to compare for equality

Definition at line 321 of file BlockPattern1D.h.

          {
    // no need to compare all members as most are derived from
    // constructor arguments.
    return (
      this == &other
      || ( _size        == other._size &&
           _distspec    == other._distspec &&
           _teamspec    == other._teamspec &&
           _nblocks     == other._nblocks &&
           _nlblocks    == other._nlblocks &&
           _local_size  == other._local_size &&
           _blocksize   == other._blocksize &&
           _nunits      == other._nunits &&
           _lbegin_lend == other._lbegin_lend
         )
      );
  }

size()

template<MemArrange Arrangement, typename IndexType >

constexpr IndexType dash::BlockPattern< 1, Arrangement, IndexType >::size ( ) const

inlinenoexcept

The number of elements arranged in this pattern.

See also

Pattern Concept

Definition at line 1013 of file BlockPattern1D.h.

                                            {
    return _size;
  }

sizespec()

template<MemArrange Arrangement, typename IndexType >

constexpr SizeSpec_t dash::BlockPattern< 1, Arrangement, IndexType >::sizespec ( ) const

inline

Size specification of the index space mapped by this pattern.

See also

Pattern Concept

Definition at line 1037 of file BlockPattern1D.h.

                                        {
    return SizeSpec_t(std::array<SizeType, 1> {{ _size }});
  }

team()

template<MemArrange Arrangement, typename IndexType >

constexpr dash::Team& dash::BlockPattern< 1, Arrangement, IndexType >::team ( ) const

inlinenoexcept

The Team containing the units to which this pattern's elements are mapped.

Definition at line 1021 of file BlockPattern1D.h.

                                             {
    return *_team;
  }

teamspec()

template<MemArrange Arrangement, typename IndexType >

constexpr const TeamSpec_t& dash::BlockPattern< 1, Arrangement, IndexType >::teamspec ( ) const

inline

Cartesian arrangement of the Team containing the units to which this pattern's elements are mapped.

See also

Pattern Concept

Definition at line 1056 of file BlockPattern1D.h.

                                                {
    return _teamspec;
  }

underfilled_blocksize()

template<MemArrange Arrangement, typename IndexType >

constexpr SizeType dash::BlockPattern< 1, Arrangement, IndexType >::underfilled_blocksize ( dim_t  dimension ) const

inline

Number of elements missing in the overflow block of given dimension compared to the regular blocksize (.

See also

blocksize(d)), with 0 <= underfilled_blocksize(d) < blocksize(d).

Definition at line 1102 of file BlockPattern1D.h.

References dash::BlockPattern< NumDimensions, Arrangement, IndexType >::BlockPattern(), dash::BlockPattern< NumDimensions, Arrangement, IndexType >::blocksize(), dash::BlockPattern< NumDimensions, Arrangement, IndexType >::distspec(), dash::BlockPattern< NumDimensions, Arrangement, IndexType >::global(), dash::BlockPattern< NumDimensions, Arrangement, IndexType >::local_size(), dash::Distribution::max_blocksize_in_range(), dash::Team::size(), and dash::BlockPattern< NumDimensions, Arrangement, IndexType >::size().

                           {
    // Underflow blocksize = regular blocksize - overflow blocksize:
    return ( _blocksize == 0 || _size % _blocksize == 0
             ? 0
             : _blocksize - (_size % _blocksize)
           );
  }

unit_at() [1/4]

template<MemArrange Arrangement, typename IndexType >

constexpr team_unit_t dash::BlockPattern< 1, Arrangement, IndexType >::unit_at ( const std::array< IndexType, NumDimensions > &  coords, const ViewSpec_t &  viewspec  ) const

inline

unit_at

Convert given point in pattern to its assigned unit id.

See also

Pattern Concept

Parameters

coords	Absolute coordinates of the point
viewspec	View specification (offsets) to apply on coords

Definition at line 379 of file BlockPattern1D.h.

                                       {
    return team_unit_t (((coords[0] + viewspec.offset(0)) / _blocksize)
                        % _nunits);
  }

unit_at() [2/4]

template<MemArrange Arrangement, typename IndexType >

constexpr team_unit_t dash::BlockPattern< 1, Arrangement, IndexType >::unit_at ( const std::array< IndexType, NumDimensions > &  coords ) const

inline

Convert given coordinate in pattern to its assigned unit id.

See also

Pattern Concept

Definition at line 393 of file BlockPattern1D.h.

                                                             {
    return team_unit_t((coords[0] / _blocksize) % _nunits);
  }

unit_at() [3/4]

template<MemArrange Arrangement, typename IndexType >

constexpr team_unit_t dash::BlockPattern< 1, Arrangement, IndexType >::unit_at ( IndexType  global_pos, const ViewSpec_t &  viewspec  ) const

inline

Convert given global linear index to its assigned unit id.

See also

Pattern Concept

Parameters

global_pos	Global linear element offset
viewspec	View to apply global position

Definition at line 403 of file BlockPattern1D.h.

          {
    return team_unit_t(((global_pos + viewspec.offset(0)) / _blocksize)
                       % _nunits);
  }

unit_at() [4/4]

template<MemArrange Arrangement, typename IndexType >

constexpr team_unit_t dash::BlockPattern< 1, Arrangement, IndexType >::unit_at ( IndexType  global_pos ) const

inline

Convert given global linear index to its assigned unit id.

See also

Pattern Concept

Parameters

global_pos

Global linear element offset

Definition at line 418 of file BlockPattern1D.h.

          {
    return team_unit_t((global_pos / _blocksize) % _nunits);
  }

---

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

• /tmp/tmporruphar/dash/include/dash/pattern/BlockPattern1D.h