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

Irregular dynamic pattern. More...

#include <DynamicPattern.h>

Classes
struct	local_coords_t
struct	local_index_t

Public Types
typedef pattern_partitioning_properties< pattern_partitioning_tag::minimal, pattern_partitioning_tag::rectangular, pattern_partitioning_tag::balanced, pattern_partitioning_tag::unbalanced, pattern_partitioning_tag::dynamic >	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::blocked, 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>
	DynamicPattern (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...
	DynamicPattern (const SizeSpec_t &sizespec, const DistributionSpec_t &distspec, const TeamSpec_t &teamspec, Team &team=dash::Team::All())
	Constructor, initializes a pattern from explicit instances of SizeSpec, DistributionSpec, TeamSpec and Team. More...
	DynamicPattern (const SizeSpec_t &sizespec, const DistributionSpec_t &distspec, Team &team=dash::Team::All())
	Constructor, initializes a pattern from explicit instances of SizeSpec, DistributionSpec and Team. More...
template<typename ... Args>
	DynamicPattern (const std::vector< size_type > &local_sizes, 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...
	DynamicPattern (const std::vector< size_type > &local_sizes, 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...
	DynamicPattern (const std::vector< size_type > &local_sizes, Team &team=dash::Team::All())
	Constructor, initializes a pattern from explicit instances of SizeSpec, DistributionSpec, TeamSpec and a Team. More...
	DynamicPattern (const self_t &other)
	Copy constructor. More...
	DynamicPattern (self_t &other)
	Copy constructor using non-const lvalue reference parameter. More...
bool	operator== (const self_t &other) const
	Equality comparison operator. More...
bool	operator!= (const self_t &other) const
	Inquality comparison operator. More...
self_t &	operator= (const self_t &other)=default
	Assignment operator. More...
IndexType	lbegin () const
	Resolves the global index of the first local element in the pattern. More...
IndexType	lend () const
	Resolves the global index past the last local element in the pattern. More...
void	local_resize (team_unit_t unit, size_type local_size)
	resize / balance More...
void	local_resize (size_type local_size)
	Update the number of local elements of the active unit. More...
void	balance ()
	Balance the number of local elements across all units in the pattern's associated team. More...
team_unit_t	unit_at (const std::array< IndexType, NumDimensions > &coords, const ViewSpec_t &viewspec) const
	unit_at More...
team_unit_t	unit_at (const std::array< IndexType, NumDimensions > &g_coords) const
	Convert given coordinate in pattern to its assigned unit id. More...
team_unit_t	unit_at (IndexType global_pos, const ViewSpec_t &viewspec) const
	Convert given global linear index to its assigned unit id. More...
team_unit_t	unit_at (IndexType g_index) const
	Convert given global linear index to its assigned unit id. More...
IndexType	extent (dim_t dim) const
	extent 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...
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...
IndexType	local_at (const std::array< IndexType, NumDimensions > &local_coords, const ViewSpec_t &viewspec) const
	local More...
IndexType	local_at (const std::array< IndexType, NumDimensions > &local_coords) const
	Convert given local coordinates to linear local offset (index). More...
local_coords_t	local (const std::array< IndexType, NumDimensions > &g_coords) const
	Converts global coordinates to their associated unit and its respective local coordinates. More...
local_index_t	local (IndexType g_index) const
	Converts global index to its associated unit and respective local index. More...
std::array< IndexType, NumDimensions >	local_coords (const std::array< IndexType, NumDimensions > &g_coords) const
	Converts global coordinates to their associated unit's respective local coordinates. More...
local_index_t	local_index (const std::array< IndexType, NumDimensions > &g_coords) const
	Converts global coordinates to their associated unit and their respective local index. More...
std::array< IndexType, NumDimensions >	global (team_unit_t unit, const std::array< IndexType, NumDimensions > &local_coords) const
	global More...
std::array< IndexType, NumDimensions >	global (const std::array< IndexType, NumDimensions > &l_coords) const
	Converts local coordinates of active unit to global coordinates. More...
IndexType	global (team_unit_t unit, IndexType l_index) const
	Resolve an element's linear global index from the given unit's local index of that element. More...
IndexType	global (IndexType l_index) const
	Resolve an element's linear global index from the calling unit's local index of that element. More...
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...
IndexType	at (const std::array< IndexType, NumDimensions > &g_coords) const
	at More...
IndexType	at (const std::array< IndexType, NumDimensions > &g_coords, const ViewSpec_t &viewspec) const
	Global coordinates and viewspec to local index. More...
template<typename ... Values>
IndexType	at (IndexType value, Values ... values) const
	Global coordinates to local index. More...
bool	has_local_elements (dim_t dim, IndexType dim_offset, team_unit_t unit, const ViewSpec_t &viewspec) const
	is_local More...
bool	is_local (IndexType index, team_unit_t unit) const
	Whether the given global index is local to the specified unit. More...
bool	is_local (IndexType index) const
	Whether the given global index is local to the unit that created this pattern instance. More...
const BlockSpec_t &	blockspec () const
	block More...
index_type	block_at (const std::array< index_type, NumDimensions > &g_coords) const
	Index of block at given global coordinates. More...
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...
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...
SizeType	blocksize (dim_t dimension) const
	Maximum number of elements in a single block in the given dimension. More...
SizeType	max_blocksize () const
	Maximum number of elements in a single block in all dimensions. More...
SizeType	local_capacity (team_unit_t unit=UNDEFINED_TEAM_UNIT_ID) const
	Maximum number of elements assigned to a single unit in total, equivalent to the local capacity of every unit in this pattern. More...
SizeType	local_size (team_unit_t unit=UNDEFINED_TEAM_UNIT_ID) const
	The actual number of elements in this pattern that are local to the calling unit in total. More...
IndexType	num_units () const
	The number of units to which this pattern's elements are mapped. More...
IndexType	capacity () const
	The maximum number of elements arranged in this pattern. More...
IndexType	size () const
	The number of elements arranged in this pattern. More...
dash::Team &	team () const
	The Team containing the units to which this pattern's elements are mapped. More...
const DistributionSpec_t &	distspec () const
	Distribution specification of this pattern. More...
SizeSpec_t	sizespec () const
	Size specification of the index space mapped by this pattern. More...
const std::array< SizeType, NumDimensions > &	extents () const
	Size specification of the index space mapped by this pattern. More...
const TeamSpec_t &	teamspec () const
	Cartesian arrangement of the Team containing the units to which this pattern's elements are mapped. More...
std::array< IndexType, NumDimensions >	coords (IndexType index) const
	Convert given global linear offset (index) to global cartesian coordinates. More...
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...

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 char const *	PatternName = "DynamicPattern1D"

Detailed Description

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

Irregular dynamic pattern.

Specialization for 1-dimensional data.

Implemented concept:

Pattern Concept

Definition at line 46 of file DynamicPattern.h.

Member Typedef Documentation

layout_properties

template<MemArrange Arrangement, typename IndexType >

typedef pattern_layout_properties< pattern_layout_tag::blocked, pattern_layout_tag::linear > dash::DynamicPattern< 1, Arrangement, IndexType >::layout_properties

Satisfiable properties in pattern property category Layout:

Definition at line 81 of file DynamicPattern.h.

mapping_properties

template<MemArrange Arrangement, typename IndexType >

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

Satisfiable properties in pattern property category Mapping:

Definition at line 73 of file DynamicPattern.h.

partitioning_properties

template<MemArrange Arrangement, typename IndexType >

typedef pattern_partitioning_properties< pattern_partitioning_tag::minimal, pattern_partitioning_tag::rectangular, pattern_partitioning_tag::balanced, pattern_partitioning_tag::unbalanced, pattern_partitioning_tag::dynamic > dash::DynamicPattern< 1, Arrangement, IndexType >::partitioning_properties

Satisfiable properties in pattern property category Partitioning:

Definition at line 68 of file DynamicPattern.h.

Constructor & Destructor Documentation

DynamicPattern() [1/8]

template<MemArrange Arrangement, typename IndexType >

template<typename ... Args>

dash::DynamicPattern< 1, Arrangement, IndexType >::DynamicPattern ( 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.

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 128 of file DynamicPattern.h.

  : DynamicPattern(PatternArguments_t(arg, args...))

  {
    DASH_LOG_TRACE("DynamicPattern()", "Constructor with argument list");
    DASH_ASSERT_EQ(
      _local_sizes.size(), _nunits,
      "Number of given local sizes "   << _local_sizes.size() << " " <<
      "does not match number of units" << _nunits);
    initialize_local_range();
    DASH_LOG_TRACE("DynamicPattern()", "DynamicPattern initialized");
  }

DynamicPattern() [2/8]

template<MemArrange Arrangement, typename IndexType >

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

inline

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

Parameters

sizespec	Size spec of the pattern.
distspec	Distribution spec.
teamspec	Cartesian arrangement of units within the team
team	Team containing units to which this pattern maps its elements.

Definition at line 154 of file DynamicPattern.h.

  : _size(sizespec.size()),
    _local_sizes(initialize_local_sizes(
        _size,
        distspec,
        team)),
    _block_offsets(initialize_block_offsets(
        _local_sizes)),
    _memory_layout(std::array<SizeType, 1> { _size }),
    _blockspec(initialize_blockspec(
        _size,
        _local_sizes)),
    _distspec(DistributionSpec_t()),
    _team(&team),
    _myid(_team->myid()),
    _teamspec(
      teamspec,
      _distspec,
      *_team),
    _nunits(_team->size()),
    _blocksize(initialize_blocksize(
        _size,
        _distspec,
        _nunits)),
    _nblocks(_nunits),
    _local_size(
        initialize_local_extent(_team->myid())),
    _local_memory_layout(std::array<SizeType, 1> { _local_size }),
    _local_capacity(initialize_local_capacity())
  {
    DASH_LOG_TRACE("DynamicPattern()", "(sizespec, dist, team)");
    DASH_ASSERT_EQ(
      _local_sizes.size(), _nunits,
      "Number of given local sizes "   << _local_sizes.size() << " " <<
      "does not match number of units" << _nunits);
    initialize_local_range();
    DASH_LOG_TRACE("DynamicPattern()", "DynamicPattern initialized");
  }

DynamicPattern() [3/8]

template<MemArrange Arrangement, typename IndexType >

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

inline

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

Parameters

sizespec	Size spec of the pattern.
distspec	Distribution spec.
team	Team containing units to which this pattern maps its elements.

Definition at line 206 of file DynamicPattern.h.

  : _size(sizespec.size()),
    _local_sizes(initialize_local_sizes(
        _size,
        distspec,
        team)),
    _block_offsets(initialize_block_offsets(
        _local_sizes)),
    _memory_layout(std::array<SizeType, 1> { _size }),
    _blockspec(initialize_blockspec(
        _size,
        _local_sizes)),
    _distspec(DistributionSpec_t()),
    _team(&team),
    _myid(_team->myid()),
    _teamspec(_distspec, *_team),
    _nunits(_team->size()),
    _blocksize(initialize_blocksize(
        _size,
        _distspec,
        _nunits)),
    _nblocks(_nunits),
    _local_size(
        initialize_local_extent(_team->myid())),
    _local_memory_layout(std::array<SizeType, 1> { _local_size }),
    _local_capacity(initialize_local_capacity())
  {
    DASH_LOG_TRACE("DynamicPattern()", "(sizespec, dist, team)");
    DASH_ASSERT_EQ(
      _local_sizes.size(), _nunits,
      "Number of given local sizes "   << _local_sizes.size() << " " <<
      "does not match number of units" << _nunits);
    initialize_local_range();
    DASH_LOG_TRACE("DynamicPattern()", "DynamicPattern initialized");
  }

DynamicPattern() [4/8]

template<MemArrange Arrangement, typename IndexType >

template<typename ... Args>

dash::DynamicPattern< 1, Arrangement, IndexType >::DynamicPattern ( const std::vector< size_type > &  local_sizes, 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.

Parameters

local_sizes	Number of local elements for every unit in the active team.
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 255 of file DynamicPattern.h.

  : DynamicPattern(local_sizes, PatternArguments_t(arg, args...))
  {
    DASH_LOG_TRACE("DynamicPattern()", "Constructor with argument list");
    DASH_ASSERT_EQ(
      _local_sizes.size(), _nunits,
      "Number of given local sizes "   << _local_sizes.size() << " " <<
      "does not match number of units" << _nunits);
    initialize_local_range();
    DASH_LOG_TRACE("DynamicPattern()", "DynamicPattern initialized");
  }

DynamicPattern() [5/8]

template<MemArrange Arrangement, typename IndexType >

dash::DynamicPattern< 1, Arrangement, IndexType >::DynamicPattern ( const std::vector< size_type > &  local_sizes, 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.

Parameters

local_sizes	Number of local elements for every unit in the active team.
teamspec	Cartesian arrangement of units within the team
team	Team containing units to which this pattern maps its elements

Definition at line 282 of file DynamicPattern.h.

  : _size(initialize_size(
        local_sizes)),
    _local_sizes(local_sizes),
    _block_offsets(initialize_block_offsets(
        _local_sizes)),
    _memory_layout(std::array<SizeType, 1> { _size }),
    _blockspec(initialize_blockspec(
        _size,
        _local_sizes)),
    _distspec(DistributionSpec_t()),
    _team(&team),
    _myid(_team->myid()),
    _teamspec(
        teamspec,
        _distspec,
        *_team),
    _nunits(_team->size()),
    _blocksize(initialize_blocksize(
        _size,
        _distspec,
        _nunits)),
    _nblocks(_nunits),
    _local_size(
        initialize_local_extent(_team->myid())),
    _local_memory_layout(std::array<SizeType, 1> { _local_size }),
    _local_capacity(initialize_local_capacity())
  {
    DASH_LOG_TRACE("DynamicPattern()", "(sizespec, dist, teamspec, team)");
    DASH_ASSERT_EQ(
      _local_sizes.size(), _nunits,
      "Number of given local sizes "   << _local_sizes.size() << " " <<
      "does not match number of units" << _nunits);
    initialize_local_range();
    DASH_LOG_TRACE("DynamicPattern()", "DynamicPattern initialized");
  }

DynamicPattern() [6/8]

template<MemArrange Arrangement, typename IndexType >

dash::DynamicPattern< 1, Arrangement, IndexType >::DynamicPattern ( const std::vector< size_type > &  local_sizes, Team &  team = dash::Team::All()  )

inline

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

Parameters

local_sizes	Number of local elements for every unit in the active team.
team	Team containing units to which this pattern maps its elements

Definition at line 330 of file DynamicPattern.h.

  : _size(initialize_size(
        local_sizes)),
    _local_sizes(local_sizes),
    _block_offsets(initialize_block_offsets(
        _local_sizes)),
    _memory_layout(std::array<SizeType, 1> { _size }),
    _blockspec(initialize_blockspec(
        _size,
        _local_sizes)),
    _distspec(DistributionSpec_t()),
    _team(&team),
    _myid(_team->myid()),
    _teamspec(_distspec, *_team),
    _nunits(_team->size()),
    _blocksize(initialize_blocksize(
        _size,
        _distspec,
        _nunits)),
    _nblocks(_nunits),
    _local_size(
        initialize_local_extent(_team->myid())),
    _local_memory_layout(std::array<SizeType, 1> { _local_size }),
    _local_capacity(initialize_local_capacity())
  {
    DASH_LOG_TRACE("DynamicPattern()", "(sizespec, dist, team)");
    DASH_ASSERT_EQ(
      _local_sizes.size(), _nunits,
      "Number of given local sizes "   << _local_sizes.size() << " " <<
      "does not match number of units" << _nunits);
    initialize_local_range();
    DASH_LOG_TRACE("DynamicPattern()", "DynamicPattern initialized");
  }

DynamicPattern() [7/8]

template<MemArrange Arrangement, typename IndexType >

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

inline

Copy constructor.

Definition at line 371 of file DynamicPattern.h.

  : _size(other._size),
    _local_sizes(other._local_sizes),
    _block_offsets(other._block_offsets),
    _memory_layout(other._memory_layout),
    _blockspec(other._blockspec),
    _distspec(other._distspec),
    _team(other._team),
    _myid(other._myid),
    _teamspec(other._teamspec),
    _nunits(other._nunits),
    _blocksize(other._blocksize),
    _nblocks(other._nblocks),
    _local_size(other._local_size),
    _local_memory_layout(other._local_memory_layout),
    _local_capacity(other._local_capacity),
    _lbegin(other._lbegin),
    _lend(other._lend)
  {
    // No need to copy _arguments as it is just used to
    // initialize other members.
    DASH_LOG_TRACE("DynamicPattern(other)", "DynamicPattern copied");
  }

DynamicPattern() [8/8]

template<MemArrange Arrangement, typename IndexType >

dash::DynamicPattern< 1, Arrangement, IndexType >::DynamicPattern ( 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 401 of file DynamicPattern.h.

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

Member Function Documentation

at() [1/3]

template<MemArrange Arrangement, typename IndexType >

IndexType dash::DynamicPattern< 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 882 of file DynamicPattern.h.

  {
    return local_coords(g_coords)[0];
  }

at() [2/3]

template<MemArrange Arrangement, typename IndexType >

IndexType dash::DynamicPattern< 1, Arrangement, IndexType >::at ( const std::array< IndexType, NumDimensions > &  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 895 of file DynamicPattern.h.

  {
    auto vs_coords = g_coords;
    vs_coords[0] += viewspec.offset(0);
    return local_coords(vs_coords)[0];
  }

at() [3/3]

template<MemArrange Arrangement, typename IndexType >

template<typename ... Values>

IndexType dash::DynamicPattern< 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 912 of file DynamicPattern.h.

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

balance()

template<MemArrange Arrangement, typename IndexType >

void dash::DynamicPattern< 1, Arrangement, IndexType >::balance ( )

inline

Balance the number of local elements across all units in the pattern's associated team.

Definition at line 487 of file DynamicPattern.h.

  {
  }

block()

template<MemArrange Arrangement, typename IndexType >

ViewSpec_t dash::DynamicPattern< 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.

Definition at line 1029 of file DynamicPattern.h.

  {
    DASH_LOG_DEBUG_VAR("DynamicPattern<1>.block >", g_block_index);
    index_type offset = _block_offsets[g_block_index];
    auto block_size   = _local_sizes[g_block_index];
    std::array<index_type, NumDimensions> offsets = { offset };
    std::array<size_type, NumDimensions>  extents = { block_size };
    ViewSpec_t block_vs(offsets, extents);
    DASH_LOG_DEBUG_VAR("DynamicPattern<1>.block >", block_vs);
    return block_vs;
  }

block_at()

template<MemArrange Arrangement, typename IndexType >

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

inline

Index of block at given global coordinates.

See also

Pattern Concept

Parameters

g_coords

Global coordinates of element

Definition at line 1009 of file DynamicPattern.h.

  {
    DASH_LOG_TRACE_VAR("DynamicPattern.block_at()", g_coords);
    auto g_coord         = g_coords[0];
    for (index_type block_idx = 0; block_idx < _nunits - 1; ++block_idx) {
      if (_block_offsets[block_idx+1] >= g_coord) {
        DASH_LOG_TRACE_VAR("DynamicPattern.block_at >", block_idx);
        return block_idx;
      }
    }
    DASH_LOG_TRACE_VAR("DynamicPattern.block_at >", _nunits-1);
    return _nunits-1;
  }

blocksize()

template<MemArrange Arrangement, typename IndexType >

SizeType dash::DynamicPattern< 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 1085 of file DynamicPattern.h.

  {
    return _blocksize;
  }

blockspec()

template<MemArrange Arrangement, typename IndexType >

const BlockSpec_t& dash::DynamicPattern< 1, Arrangement, IndexType >::blockspec ( ) const

inline

block

Cartesian arrangement of pattern blocks.

Definition at line 999 of file DynamicPattern.h.

  {
    return _blockspec;
  }

capacity()

template<MemArrange Arrangement, typename IndexType >

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

inline

The maximum number of elements arranged in this pattern.

See also

Pattern Concept

Definition at line 1148 of file DynamicPattern.h.

  {
    return _size;
  }

coords() [1/2]

template<MemArrange Arrangement, typename IndexType >

std::array<IndexType, NumDimensions> dash::DynamicPattern< 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 1217 of file DynamicPattern.h.

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

coords() [2/2]

template<MemArrange Arrangement, typename IndexType >

std::array<IndexType, NumDimensions> dash::DynamicPattern< 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 1229 of file DynamicPattern.h.

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

distspec()

template<MemArrange Arrangement, typename IndexType >

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

inline

Distribution specification of this pattern.

Definition at line 1175 of file DynamicPattern.h.

  {
    return _distspec;
  }

extent()

template<MemArrange Arrangement, typename IndexType >

IndexType dash::DynamicPattern< 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 592 of file DynamicPattern.h.

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

extents()

template<MemArrange Arrangement, typename IndexType >

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

inline

Size specification of the index space mapped by this pattern.

See also

Pattern Concept

Definition at line 1195 of file DynamicPattern.h.

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

global() [1/4]

template<MemArrange Arrangement, typename IndexType >

std::array<IndexType, NumDimensions> dash::DynamicPattern< 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 798 of file DynamicPattern.h.

  {
    DASH_LOG_DEBUG_VAR("DynamicPattern.global()", unit);
    DASH_LOG_DEBUG_VAR("DynamicPattern.global()", local_coords);
    DASH_LOG_TRACE_VAR("DynamicPattern.global", _nunits);
    if (_nunits < 2) {
      return local_coords;
    }
    // Initialize global index with element phase (= local coords):
    index_type glob_index = _block_offsets[unit] + local_coords[0];
    DASH_LOG_TRACE_VAR("DynamicPattern.global >", glob_index);
    return std::array<IndexType, 1> { glob_index };
  }

global() [2/4]

template<MemArrange Arrangement, typename IndexType >

std::array<IndexType, NumDimensions> dash::DynamicPattern< 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 819 of file DynamicPattern.h.

References dash::global().

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

global() [3/4]

template<MemArrange Arrangement, typename IndexType >

IndexType dash::DynamicPattern< 1, Arrangement, IndexType >::global ( team_unit_t  unit, IndexType  l_index  ) const

inline

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

See also

at Inverse of local()

Pattern Concept

Definition at line 833 of file DynamicPattern.h.

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

global() [4/4]

template<MemArrange Arrangement, typename IndexType >

IndexType dash::DynamicPattern< 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 local()

Pattern Concept

Definition at line 848 of file DynamicPattern.h.

References dash::global().

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

global_index()

template<MemArrange Arrangement, typename IndexType >

IndexType dash::DynamicPattern< 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 862 of file DynamicPattern.h.

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

has_local_elements()

template<MemArrange Arrangement, typename IndexType >

bool dash::DynamicPattern< 1, Arrangement, IndexType >::has_local_elements ( dim_t  dim, IndexType  dim_offset, team_unit_t  unit, const ViewSpec_t &  viewspec  ) 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
viewspec	Viewspec to apply

Definition at line 933 of file DynamicPattern.h.

  {
    DASH_ASSERT_EQ(
      0, dim,
      "Wrong dimension for Pattern::has_local_elements. " <<
      "Expected dimension = 0, got " << dim);
    DASH_LOG_TRACE_VAR("DynamicPattern.has_local_elements()", dim_offset);
    DASH_LOG_TRACE_VAR("DynamicPattern.has_local_elements()", unit);
    DASH_LOG_TRACE_VAR("DynamicPattern.has_local_elements()", viewspec);
    DASH_THROW(
      dash::exception::NotImplemented,
      "DynamicPattern.has_local_elements is not implemented");
  }

is_local() [1/2]

template<MemArrange Arrangement, typename IndexType >

bool dash::DynamicPattern< 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 960 of file DynamicPattern.h.

  {
    DASH_LOG_TRACE_VAR("DynamicPattern.is_local()", index);
    DASH_LOG_TRACE_VAR("DynamicPattern.is_local()", unit);
    bool is_loc = index >= _block_offsets[unit] &&
                  (unit == _nunits-1 ||
                   index <  _block_offsets[unit+1]);
    DASH_LOG_TRACE_VAR("DynamicPattern.is_local >", is_loc);
    return is_loc;
  }

is_local() [2/2]

template<MemArrange Arrangement, typename IndexType >

bool dash::DynamicPattern< 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 979 of file DynamicPattern.h.

  {
    auto unit = team().myid();
    DASH_LOG_TRACE_VAR("DynamicPattern.is_local()", index);
    DASH_LOG_TRACE_VAR("DynamicPattern.is_local", unit);
    bool is_loc = index >= _block_offsets[unit] &&
                  (unit == _nunits-1 ||
                   index <  _block_offsets[unit+1]);
    DASH_LOG_TRACE_VAR("DynamicPattern.is_local >", is_loc);
    return is_loc;
  }

lbegin()

template<MemArrange Arrangement, typename IndexType >

IndexType dash::DynamicPattern< 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 448 of file DynamicPattern.h.

  {
    return _lbegin;
  }

lend()

template<MemArrange Arrangement, typename IndexType >

IndexType dash::DynamicPattern< 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 458 of file DynamicPattern.h.

  {
    return _lend;
  }

local() [1/2]

template<MemArrange Arrangement, typename IndexType >

local_coords_t dash::DynamicPattern< 1, Arrangement, IndexType >::local ( const std::array< IndexType, NumDimensions > &  g_coords ) const

inline

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

NOTE: Same as local_index.

See also

Pattern Concept

Definition at line 679 of file DynamicPattern.h.

  {
    DASH_LOG_TRACE_VAR("DynamicPattern.local()", g_coords);
    IndexType     g_index = g_coords[0];
    local_index_t l_index;
    for (auto unit_idx = _nunits-1; unit_idx >= 0; --unit_idx) {
      index_type block_offset = _block_offsets[unit_idx];
      if (block_offset <= g_index) {
        l_index.unit  = unit_idx;
        l_index.index = g_index - block_offset;
        DASH_LOG_TRACE_VAR("DynamicPattern.local >", l_index.unit);
        DASH_LOG_TRACE_VAR("DynamicPattern.local >", l_index.index);
        return l_index;
      }
    }
    DASH_THROW(
      dash::exception::InvalidArgument,
      "DynamicPattern.local: global coord " << g_index << " is out of bounds");
  }

local() [2/2]

template<MemArrange Arrangement, typename IndexType >

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

inline

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

NOTE: Same as local_index.

See also

Pattern Concept

Definition at line 707 of file DynamicPattern.h.

  {
    DASH_LOG_TRACE_VAR("DynamicPattern.local()", g_index);
    DASH_LOG_TRACE_VAR("DynamicPattern.local", _block_offsets.size());
    DASH_ASSERT_GT(_nunits, 0,
                   "team size is 0");
    DASH_ASSERT_GE(_block_offsets.size(), _nunits,
                   "missing block offsets");
    local_index_t l_index;
    index_type    unit_idx = static_cast<index_type>(_nunits-1);
    for (; unit_idx >= 0; --unit_idx) {
      DASH_LOG_TRACE_VAR("DynamicPattern.local", unit_idx);
      index_type block_offset = _block_offsets[unit_idx];
      DASH_LOG_TRACE_VAR("DynamicPattern.local", block_offset);
      if (block_offset <= g_index) {
        l_index.unit  = unit_idx;
        l_index.index = g_index - block_offset;
        DASH_LOG_TRACE_VAR("DynamicPattern.local >", l_index.unit);
        DASH_LOG_TRACE_VAR("DynamicPattern.local >", l_index.index);
        return l_index;
      }
    }
    DASH_THROW(
      dash::exception::InvalidArgument,
      "DynamicPattern.local: global index " << g_index << " is out of bounds");
  }

local_at() [1/2]

template<MemArrange Arrangement, typename IndexType >

IndexType dash::DynamicPattern< 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 650 of file DynamicPattern.h.

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

local_at() [2/2]

template<MemArrange Arrangement, typename IndexType >

IndexType dash::DynamicPattern< 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 664 of file DynamicPattern.h.

  {
    return local_coords[0];
  }

local_block()

template<MemArrange Arrangement, typename IndexType >

ViewSpec_t dash::DynamicPattern< 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.

Definition at line 1046 of file DynamicPattern.h.

  {
    DASH_LOG_DEBUG_VAR("DynamicPattern<1>.local_block()", l_block_index);
    DASH_ASSERT_EQ(
      0, l_block_index,
      "DynamicPattern always assigns exactly 1 block to a single unit");
    index_type block_offset = _block_offsets[_team->myid()];
    size_type  block_size   = _local_sizes[_team->myid()];
    std::array<index_type, NumDimensions> offsets = { block_offset };
    std::array<size_type, NumDimensions>  extents = { block_size };
    ViewSpec_t block_vs(offsets, extents);
    DASH_LOG_DEBUG_VAR("DynamicPattern<1>.local_block >", block_vs);
    return block_vs;
  }

local_block_local()

template<MemArrange Arrangement, typename IndexType >

ViewSpec_t dash::DynamicPattern< 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 1066 of file DynamicPattern.h.

  {
    DASH_LOG_DEBUG_VAR("DynamicPattern<1>.local_block_local >", l_block_index);
    size_type block_size = _local_sizes[_team->myid()];
    std::array<index_type, NumDimensions> offsets = { 0 };
    std::array<size_type, NumDimensions>  extents = { block_size };
    ViewSpec_t block_vs(offsets, extents);
    DASH_LOG_DEBUG_VAR("DynamicPattern<1>.local_block_local >", block_vs);
    return block_vs;
  }

local_capacity()

template<MemArrange Arrangement, typename IndexType >

SizeType dash::DynamicPattern< 1, Arrangement, IndexType >::local_capacity ( team_unit_t  unit = UNDEFINED_TEAM_UNIT_ID ) 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 1111 of file DynamicPattern.h.

  {
    return _local_capacity;
  }

local_coords()

template<MemArrange Arrangement, typename IndexType >

std::array<IndexType, NumDimensions> dash::DynamicPattern< 1, Arrangement, IndexType >::local_coords ( const std::array< IndexType, NumDimensions > &  g_coords ) const

inline

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

See also

Pattern Concept

Definition at line 741 of file DynamicPattern.h.

  {
    DASH_LOG_TRACE_VAR("DynamicPattern.local_coords()", g_coords);
    IndexType  g_index  = g_coords[0];
    index_type unit_idx = static_cast<index_type>(_nunits-1);
    for (; unit_idx >= 0; --unit_idx) {
      index_type block_offset = _block_offsets[unit_idx];
      if (block_offset <= g_index) {
        auto l_coord = g_index - block_offset;
        DASH_LOG_TRACE_VAR("DynamicPattern.local_coords >", l_coord);
        return std::array<IndexType, 1> { l_coord };
      }
    }
    DASH_THROW(
      dash::exception::InvalidArgument,
      "DynamicPattern.local_coords: global index " << g_index <<
      " is out of bounds");
  }

local_extent()

template<MemArrange Arrangement, typename IndexType >

IndexType dash::DynamicPattern< 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 612 of file DynamicPattern.h.

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

local_extents()

template<MemArrange Arrangement, typename IndexType >

std::array<SizeType, NumDimensions> dash::DynamicPattern< 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 632 of file DynamicPattern.h.

  {
    DASH_LOG_DEBUG_VAR("DynamicPattern.local_extents()", unit);
    DASH_LOG_DEBUG_VAR("DynamicPattern.local_extents >", _local_size);
    return std::array<SizeType, 1> { _local_size };
  }

local_index()

template<MemArrange Arrangement, typename IndexType >

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

inline

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

See also

Pattern Concept

Definition at line 767 of file DynamicPattern.h.

  {
    IndexType g_index = g_coords[0];
    DASH_LOG_TRACE_VAR("DynamicPattern.local_index()", g_coords);
    local_index_t l_index;
    index_type    unit_idx = static_cast<index_type>(_nunits-1);
    for (; unit_idx >= 0; --unit_idx) {
      index_type block_offset = _block_offsets[unit_idx];
      if (block_offset <= g_index) {
        l_index.unit  = unit_idx;
        l_index.index = g_index - block_offset;
        DASH_LOG_TRACE_VAR("DynamicPattern.local >", l_index.unit);
        DASH_LOG_TRACE_VAR("DynamicPattern.local >", l_index.index);
        return l_index;
      }
    }
    DASH_THROW(
      dash::exception::InvalidArgument,
      "DynamicPattern.local: global index " << g_index << " is out of bounds");
  }

local_resize() [1/2]

template<MemArrange Arrangement, typename IndexType >

void dash::DynamicPattern< 1, Arrangement, IndexType >::local_resize ( team_unit_t  unit, size_type  local_size  )

inline

resize / balance

Update the number of local elements of the specified unit.

Definition at line 470 of file DynamicPattern.h.

  {
    _local_sizes[unit] = local_size;
  }

local_resize() [2/2]

template<MemArrange Arrangement, typename IndexType >

void dash::DynamicPattern< 1, Arrangement, IndexType >::local_resize ( size_type  local_size )

inline

Update the number of local elements of the active unit.

Definition at line 478 of file DynamicPattern.h.

  {
    _local_sizes[_myid] = local_size;
  }

local_size()

template<MemArrange Arrangement, typename IndexType >

SizeType dash::DynamicPattern< 1, Arrangement, IndexType >::local_size ( team_unit_t  unit = UNDEFINED_TEAM_UNIT_ID ) const

inline

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 1127 of file DynamicPattern.h.

  {
    return _local_size;
  }

max_blocksize()

template<MemArrange Arrangement, typename IndexType >

SizeType dash::DynamicPattern< 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 1100 of file DynamicPattern.h.

  {
    return _blocksize;
  }

memory_order()

template<MemArrange Arrangement, typename IndexType >

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

inlinestatic

Memory order followed by the pattern.

Definition at line 1240 of file DynamicPattern.h.

  {
    return Arrangement;
  }

ndim()

template<MemArrange Arrangement, typename IndexType >

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

inlinestatic

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

Definition at line 1248 of file DynamicPattern.h.

References dash::global(), dash::max_element(), dash::size(), and dash::Team::size().

  {
    return 1;
  }

num_units()

template<MemArrange Arrangement, typename IndexType >

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

inline

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

See also

Pattern Concept

Definition at line 1138 of file DynamicPattern.h.

  {
    return _nunits;
  }

operator!=()

template<MemArrange Arrangement, typename IndexType >

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

inline

Inquality comparison operator.

Parameters

other

Pattern instance to compare for inequality

Definition at line 431 of file DynamicPattern.h.

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

operator=()

template<MemArrange Arrangement, typename IndexType >

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

default

Assignment operator.

operator==()

template<MemArrange Arrangement, typename IndexType >

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

inline

Equality comparison operator.

Parameters

other

Pattern instance to compare for equality

Definition at line 408 of file DynamicPattern.h.

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

size()

template<MemArrange Arrangement, typename IndexType >

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

inline

The number of elements arranged in this pattern.

See also

Pattern Concept

Definition at line 1158 of file DynamicPattern.h.

  {
    return _size;
  }

sizespec()

template<MemArrange Arrangement, typename IndexType >

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

inline

Size specification of the index space mapped by this pattern.

See also

Pattern Concept

Definition at line 1185 of file DynamicPattern.h.

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

team()

template<MemArrange Arrangement, typename IndexType >

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

inline

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

Definition at line 1167 of file DynamicPattern.h.

  {
    return *_team;
  }

teamspec()

template<MemArrange Arrangement, typename IndexType >

const TeamSpec_t& dash::DynamicPattern< 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 1206 of file DynamicPattern.h.

  {
    return _teamspec;
  }

unit_at() [1/4]

template<MemArrange Arrangement, typename IndexType >

team_unit_t dash::DynamicPattern< 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 500 of file DynamicPattern.h.

  {
    DASH_LOG_TRACE_VAR("DynamicPattern.unit_at()", coords);
    // Apply viewspec offsets to coordinates:
    team_unit_t unit_id(((coords[0] + viewspec.offset(0)) / _blocksize)
                          % _nunits);
    DASH_LOG_TRACE_VAR("DynamicPattern.unit_at >", unit_id);
    return unit_id;
  }

unit_at() [2/4]

template<MemArrange Arrangement, typename IndexType >

team_unit_t dash::DynamicPattern< 1, Arrangement, IndexType >::unit_at ( const std::array< IndexType, NumDimensions > &  g_coords ) const

inline

Convert given coordinate in pattern to its assigned unit id.

See also

Pattern Concept

Definition at line 519 of file DynamicPattern.h.

  {
    DASH_LOG_TRACE_VAR("DynamicPattern.unit_at()", g_coords);
    auto g_coord         = g_coords[0];
    for (team_unit_t unit_idx{0}; unit_idx < _nunits - 1; ++unit_idx) {
      if (_block_offsets[unit_idx+1] >= g_coord) {
        DASH_LOG_TRACE_VAR("DynamicPattern.unit_at >", unit_idx);
        return unit_idx;
      }
    }
    DASH_LOG_TRACE_VAR("DynamicPattern.unit_at >", _nunits-1);
    return _nunits-1;
  }

unit_at() [3/4]

template<MemArrange Arrangement, typename IndexType >

team_unit_t dash::DynamicPattern< 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 539 of file DynamicPattern.h.

  {
    DASH_LOG_TRACE_VAR("DynamicPattern.unit_at()", global_pos);
    DASH_LOG_TRACE_VAR("DynamicPattern.unit_at()", viewspec);
    // Apply viewspec offsets to coordinates:
    auto g_coord         = global_pos + viewspec.offset(0);
    for (team_unit_t unit_idx{0}; unit_idx < _nunits - 1; ++unit_idx) {
      if (_block_offsets[unit_idx+1] >= static_cast<size_type>(g_coord)) {
        DASH_LOG_TRACE_VAR("DynamicPattern.unit_at >", unit_idx);
        return unit_idx;
      }
    }
    DASH_LOG_TRACE_VAR("DynamicPattern.unit_at >", _nunits-1);
    return _nunits-1;
  }

unit_at() [4/4]

template<MemArrange Arrangement, typename IndexType >

team_unit_t dash::DynamicPattern< 1, Arrangement, IndexType >::unit_at ( IndexType  g_index ) const

inline

Convert given global linear index to its assigned unit id.

See also

Pattern Concept

Parameters

g_index

Global linear element offset

Definition at line 564 of file DynamicPattern.h.

  {
    DASH_LOG_TRACE_VAR("DynamicPattern.unit_at()", g_index);
    for (team_unit_t unit_idx{0}; unit_idx < _nunits - 1; ++unit_idx) {
      if (_block_offsets[unit_idx+1] > static_cast<size_type>(g_index)) {
        DASH_LOG_TRACE_VAR("DynamicPattern.unit_at >", unit_idx);
        return unit_idx;
      }
    }
    DASH_LOG_TRACE_VAR("DynamicPattern.unit_at >", _nunits-1);
    return team_unit_t(_nunits-1);
  }

---

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

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