dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType > Class Template Reference

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

#include <ShiftTilePattern.h>

Classes
struct	local_coords_t
struct	local_index_t

Public Types
typedef pattern_partitioning_properties< pattern_partitioning_tag::rectangular, pattern_partitioning_tag::balanced >	partitioning_properties
	Satisfiable properties in pattern property category Partitioning: More...
typedef pattern_mapping_properties< pattern_mapping_tag::balanced, pattern_mapping_tag::unbalanced, pattern_mapping_tag::diagonal >	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>
	ShiftTilePattern (SizeType arg, Args &&... args)
	Constructor, initializes a pattern from an argument list consisting of the pattern size (extent, number of elements) in every dimension followed by optional distribution types. More...
	ShiftTilePattern (const SizeSpec_t &sizespec, DistributionSpec_t dist, TeamSpec_t teamspec, dash::Team &team=dash::Team::All())
	Constructor, initializes a pattern from explicit instances of SizeSpec, DistributionSpec, TeamSpec and a Team. More...
	ShiftTilePattern (const SizeSpec_t &sizespec, DistributionSpec_t dist=DistributionSpec_t(), Team &team=dash::Team::All())
	Constructor, initializes a pattern from explicit instances of SizeSpec, DistributionSpec and a Team. More...
	ShiftTilePattern (const self_t &other)
	Copy constructor. More...
	ShiftTilePattern (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...
ShiftTilePattern &	operator= (const ShiftTilePattern &other)
	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...
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 > &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 global_pos) const
	Convert given global linear index to its assigned unit id. More...
SizeType	extent (dim_t dim) const
	extent More...
SizeType	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 () 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 > &global_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 > &global_coords) const
	Converts global coordinates to their associated unit's respective local coordinates. More...
local_index_t	local_index (const std::array< IndexType, NumDimensions > &global_coords) const
	Resolves the unit and the local index from global coordinates. 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 > &local_coords) const
	Converts local coordinates of a active unit to global coordinates. More...
IndexType	global (IndexType local_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 > &local_coords) const
	Resolve an element's linear global index from a given unit's local coordinates of that element. More...
IndexType	global_at (const std::array< IndexType, NumDimensions > &global_coords, const ViewSpec_t &viewspec) const
	Global coordinates and viewspec to global position in the pattern's iteration order. More...
IndexType	global_at (const std::array< IndexType, NumDimensions > &global_coords) const
	Global coordinates to global position in the pattern's iteration order. More...
IndexType	at (const std::array< IndexType, NumDimensions > &global_coords, const ViewSpec_t &viewspec) const
	at More...
IndexType	at (std::array< IndexType, NumDimensions > global_coords) const
	Global coordinates to local index. More...
template<typename ... Values>
IndexType	at (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...
index_type	block_at (const std::array< index_type, NumDimensions > &g_coords) const
	block More...
local_index_t	local_block_at (const std::array< index_type, NumDimensions > &g_coords) const
	Unit and local block index at given global coordinates. More...
ViewSpec_t	block (index_type global_block_index) const
	View spec (offset and extents) of block at global linear block index in global cartesian element space. More...
ViewSpec_t	local_block (index_type local_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 local_block_index) const
	View spec (offset and extents) of block at local linear block index in local cartesian element space. More...
const BlockSpec_t &	blockspec () const
	Cartesian arrangement of pattern blocks. More...
const BlockSpec_t &	local_blockspec () const
	Cartesian arrangement of pattern blocks. 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 () 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 = "ShiftTilePattern"

Detailed Description

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>
class dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >

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

Expects extent[d] to be a multiple of (blocksize[d] * nunits[d]) to ensure the balanced property.

Template Parameters

NumDimensions	The number of dimensions of the pattern
Arrangement	The memory order of the pattern (ROW_MAJOR or COL_MAJOR), defaults to ROW_MAJOR. Memory order defines how elements in the pattern will be iterated predominantly

See also

MemArrange

Implemented concept:

Pattern Concept

Examples:

ex.06.pattern-block-visualizer/main.cpp.

Definition at line 46 of file ShiftTilePattern.h.

Member Typedef Documentation

layout_properties

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

typedef pattern_layout_properties< pattern_layout_tag::blocked, pattern_layout_tag::linear > dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::layout_properties

Satisfiable properties in pattern property category Layout:

Definition at line 75 of file ShiftTilePattern.h.

mapping_properties

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

typedef pattern_mapping_properties< pattern_mapping_tag::balanced, pattern_mapping_tag::unbalanced, pattern_mapping_tag::diagonal > dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::mapping_properties

Satisfiable properties in pattern property category Mapping:

Definition at line 67 of file ShiftTilePattern.h.

partitioning_properties

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

typedef pattern_partitioning_properties< pattern_partitioning_tag::rectangular, pattern_partitioning_tag::balanced > dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::partitioning_properties

Satisfiable properties in pattern property category Partitioning:

Definition at line 58 of file ShiftTilePattern.h.

Constructor & Destructor Documentation

ShiftTilePattern() [1/5]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

template<typename ... Args>

dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::ShiftTilePattern ( SizeType  arg, Args &&...  args  )

inline

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

Examples:

// A 5x3 rectangle with blocked distribution in the first dimension
ShiftTilePattern p1(10,20);
auto num_units = dash::Team::All.size();
// Same as
ShiftTilePattern p1(SizeSpec<2>(10,20,
               DistributionSpec<2>(TILE(10/num_units),
                                   TILE(20/num_units)));
// Same as
ShiftTilePattern p1(SizeSpec<2>(10,20),
               DistributionSpec<2>(TILE(10/num_units),
                                   TILE(20/num_units)));
               TeamSpec<2>(dash::Team::All(), 1));
// Same as
ShiftTilePattern p1(SizeSpec<2>(10,20),
               DistributionSpec<2>(TILE(10/num_units),
                                   TILE(20/num_units)));
               // How teams are arranged in all dimensions, default
               // is an extent of all units in first, and 1 in all
               // higher dimensions:
               TeamSpec<2>(dash::Team::All(), 1),
               // 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 189 of file ShiftTilePattern.h.

Referenced by dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::ndim().

  : ShiftTilePattern(PatternArguments_t(arg, args...)) {
    DASH_LOG_TRACE("ShiftTilePattern()", "Constructor with Argument list");
    initialize_local_range();
  }

ShiftTilePattern() [2/5]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::ShiftTilePattern ( const SizeSpec_t &  sizespec, DistributionSpec_t  dist, 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:

// A 5x3 rectangle with blocked distribution in the first dimension
ShiftTilePattern p1(10,20);
auto num_units = dash::Team::All.size();
// Same as
ShiftTilePattern p1(SizeSpec<2>(10,20,
               DistributionSpec<2>(TILE(10/num_units),
                                   TILE(20/num_units)));
// Same as
ShiftTilePattern p1(SizeSpec<2>(10,20),
               DistributionSpec<2>(TILE(10/num_units),
                                   TILE(20/num_units)));
               TeamSpec<2>(dash::Team::All(), 1));
// Same as
ShiftTilePattern p1(SizeSpec<2>(10,20),
               DistributionSpec<2>(TILE(10/num_units),
                                   TILE(20/num_units)));
               // How teams are arranged in all dimensions, default
               // is an extent of all units in first, and 1 in all
               // higher dimensions:
               TeamSpec<2>(dash::Team::All(), 1),
               // The team containing the units to which the
               // pattern maps the global indices. Defaults to all
               // all units:
               dash::Team::All());

Parameters

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

Definition at line 236 of file ShiftTilePattern.h.

    : _distspec(std::move(dist))
    , _team(&team)
    ,
    // Degrading to 1-dimensional team spec for now:
    //  _teamspec(_distspec, *_team),
    //  _teamspec(
    //    teamspec,
    //    _distspec,
    //    *_team),
    _teamspec(std::move(teamspec))
    , _memory_layout(sizespec.extents())
    , _nunits(_teamspec.size())
    , _major_tiled_dim(initialize_major_tiled_dim(_distspec))
    , _minor_tiled_dim((_major_tiled_dim + 1) % NumDimensions)
    , _blocksize_spec(
          initialize_blocksizespec(sizespec, _distspec, _teamspec))
    , _blockspec(initialize_blockspec(sizespec, _blocksize_spec, _teamspec))
    , _local_blockspec(
          initialize_local_blockspec(_blockspec, _major_tiled_dim, _nunits))
    , _local_memory_layout(initialize_local_extents(_team->myid()))
    , _local_capacity(initialize_local_capacity())
  {
    DASH_LOG_TRACE("ShiftTilePattern()", "(sizespec, dist, teamspec, team)");
    initialize_local_range();
  }

ShiftTilePattern() [3/5]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::ShiftTilePattern ( const SizeSpec_t &  sizespec, 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:

// A 5x3 rectangle with blocked distribution in the first dimension
ShiftTilePattern p1(10,20);
auto num_units = dash::Team::All.size();
// Same as
ShiftTilePattern p1(SizeSpec<2>(10,20,
               DistributionSpec<2>(TILE(10/num_units),
                                   TILE(20/num_units)));
// Same as
ShiftTilePattern p1(SizeSpec<2>(10,20),
               DistributionSpec<2>(TILE(10/num_units),
                                   TILE(20/num_units)));
               TeamSpec<2>(dash::Team::All(), 1));
// Same as
ShiftTilePattern p1(SizeSpec<2>(10,20),
               DistributionSpec<2>(TILE(10/num_units),
                                   TILE(20/num_units)));
               // How teams are arranged in all dimensions, default
               // is an extent of all units in first, and 1 in all
               // higher dimensions:
               TeamSpec<2>(dash::Team::All(), 1),
               // The team containing the units to which the
               // pattern maps the global indices. Defaults to all
               // all units:
               dash::Team::All());

Parameters

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

Definition at line 306 of file ShiftTilePattern.h.

    : _distspec(std::move(dist))
    , _team(&team)
    , _teamspec(_distspec, *_team)
    , _memory_layout(sizespec.extents())
    , _nunits(_teamspec.size())
    , _major_tiled_dim(initialize_major_tiled_dim(_distspec))
    , _minor_tiled_dim((_major_tiled_dim + 1) % NumDimensions)
    , _blocksize_spec(
          initialize_blocksizespec(sizespec, _distspec, _teamspec))
    , _blockspec(initialize_blockspec(sizespec, _blocksize_spec, _teamspec))
    , _local_blockspec(
          initialize_local_blockspec(_blockspec, _major_tiled_dim, _nunits))
    , _local_memory_layout(initialize_local_extents(_team->myid()))
    , _local_capacity(initialize_local_capacity())
  {
    DASH_LOG_TRACE("ShiftTilePattern()", "(sizespec, dist, team)");
    initialize_local_range();
  }

ShiftTilePattern() [4/5]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::ShiftTilePattern ( const self_t &  other )

inline

Copy constructor.

Definition at line 338 of file ShiftTilePattern.h.

  : _distspec(other._distspec),
    _team(other._team),
    _teamspec(other._teamspec),
    _memory_layout(other._memory_layout),
    _nunits(other._nunits),
    _major_tiled_dim(other._major_tiled_dim),
    _minor_tiled_dim(other._minor_tiled_dim),
    _blocksize_spec(other._blocksize_spec),
    _blockspec(other._blockspec),
    _local_blockspec(other._local_blockspec),
    _local_memory_layout(other._local_memory_layout),
    _local_capacity(other._local_capacity),
    _lbegin(other._lbegin),
    _lend(other._lend) {
  }

ShiftTilePattern() [5/5]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::ShiftTilePattern ( 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 361 of file ShiftTilePattern.h.

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

Member Function Documentation

at() [1/3]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

IndexType dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::at ( const std::array< IndexType, NumDimensions > &  global_coords, const ViewSpec_t &  viewspec  ) const

inline

at

Global coordinates and viewspec to local index.

NOTE: Expects extent[d] to be a multiple of blocksize[d] * nunits[d] to ensure the balanced property.

See also

global_at

Pattern Concept

Definition at line 954 of file ShiftTilePattern.h.

References dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::at(), dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::extent(), dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::extents(), and dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::size().

Referenced by dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::at().

  {
    DASH_LOG_TRACE("ShiftTilePattern.at()",
                   "gcoords:",  global_coords,
                   "viewspec:", viewspec);
    // Phase coordinates of element:
    std::array<IndexType, NumDimensions> phase_coords;
    // Coordinates of the block containing the element:
    std::array<IndexType, NumDimensions> block_coords;
    for (auto d = 0; d < NumDimensions; ++d) {
      auto vs_coord     = global_coords[d] + viewspec.offset(d);
      phase_coords[d]   = vs_coord % _blocksize_spec.extent(d);
      block_coords[d]   = vs_coord / _blocksize_spec.extent(d);
    }
    DASH_LOG_TRACE("ShiftTilePattern.at",
                   "block_coords:", block_coords,
                   "phase_coords:", phase_coords);
    // Number of blocks preceeding the coordinates' block, equivalent
    // to linear global block offset divided by team size:
    DASH_LOG_TRACE_VAR("ShiftTilePattern.at", _blockspec.extents());
    auto block_index   = _blockspec.at(block_coords);
    auto block_index_l = block_index / _nunits;
    DASH_LOG_TRACE("ShiftTilePattern.at",
                   "global block index:",block_index,
                   "nunits:",            _nunits,
                   "local block index:", block_index_l);
    auto offset = block_index_l * _blocksize_spec.size() + // preceed. blocks
                  _blocksize_spec.at(phase_coords);        // element phase
    DASH_LOG_TRACE_VAR("ShiftTilePattern.at >", offset);
    return offset;
  }

at() [2/3]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

IndexType dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::at ( std::array< IndexType, NumDimensions >  global_coords ) const

inline

Global coordinates to local index.

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

See also

Pattern Concept

Definition at line 996 of file ShiftTilePattern.h.

References dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::at(), dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::extent(), dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::extents(), and dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::size().

  {
    // Note:
    // Expects extent[d] to be a multiple of blocksize[d] * nunits[d]
    // to ensure the balanced property.
    DASH_LOG_TRACE_VAR("ShiftTilePattern.at()", global_coords);
    // Phase coordinates of element:
    std::array<IndexType, NumDimensions> phase_coords{};
    // Coordinates of the block containing the element:
    std::array<IndexType, NumDimensions> block_coords{};
    for (auto d = 0; d < NumDimensions; ++d) {
      auto coord      = global_coords[d];
      phase_coords[d] = coord % _blocksize_spec.extent(d);
      block_coords[d] = coord / _blocksize_spec.extent(d);
    }
    DASH_LOG_TRACE_VAR("ShiftTilePattern.at", block_coords);
    DASH_LOG_TRACE_VAR("ShiftTilePattern.at", phase_coords);
    // Number of blocks preceeding the coordinates' block, equivalent
    // to linear global block offset divided by team size:
    DASH_LOG_TRACE_VAR("ShiftTilePattern.at", _blockspec.extents());
    auto block_offset   = _blockspec.at(block_coords);
    auto block_offset_l = block_offset / _nunits;
    DASH_LOG_TRACE_VAR("ShiftTilePattern.at", block_offset);
    DASH_LOG_TRACE_VAR("ShiftTilePattern.at", _nunits);
    DASH_LOG_TRACE_VAR("ShiftTilePattern.at", block_offset_l);
    return block_offset_l * _blocksize_spec.size() + // preceeding blocks
           _blocksize_spec.at(phase_coords);         // element phase
  }

at() [3/3]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

template<typename ... Values>

IndexType dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::at ( 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 1034 of file ShiftTilePattern.h.

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

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

block()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

ViewSpec_t dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::block ( index_type  global_block_index ) const

inline

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

Definition at line 1156 of file ShiftTilePattern.h.

References dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::coords(), dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::extent(), dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::extents(), and dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::extents().

  {
    DASH_LOG_TRACE_VAR("ShiftTilePattern.block()", global_block_index);
    // block index -> block coords -> offset
    auto block_coords = _blockspec.coords(global_block_index);
    DASH_LOG_TRACE_VAR("ShiftTilePattern.block", block_coords);
    DASH_LOG_TRACE_VAR("ShiftTilePattern.block", _blocksize_spec.extents());
    std::array<index_type, NumDimensions> offsets{};
    std::array<size_type, NumDimensions>  extents{};
    for (auto d = 0; d < NumDimensions; ++d) {
      extents[d] = _blocksize_spec.extent(d);
      offsets[d] = block_coords[d] * extents[d];
    }
    DASH_LOG_TRACE("ShiftTilePattern.block",
                   "offsets:", offsets,
                   "extents:", extents);
    auto block_vs = ViewSpec_t(offsets, extents);
    DASH_LOG_TRACE_VAR("ShiftTilePattern.block >", block_vs);
    return block_vs;
  }

block_at()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

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

inline

block

Index of block at given global coordinates.

See also

Pattern Concept

Parameters

g_coords

Global coordinates of element

Definition at line 1121 of file ShiftTilePattern.h.

References dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::at(), and dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::extent().

  {
    std::array<index_type, NumDimensions> block_coords;
    // Coord to block coord to unit coord:
    for (auto d = 0; d < NumDimensions; ++d) {
      block_coords[d] = g_coords[d] / _blocksize_spec.extent(d);
    }
    // Block coord to block index:
    auto block_idx = _blockspec.at(block_coords);
    DASH_LOG_TRACE("ShiftTilePattern.block_at",
                   "coords", g_coords,
                   "> block index", block_idx);
    return block_idx;
  }

blocksize()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

SizeType dash::ShiftTilePattern< NumDimensions, 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 1272 of file ShiftTilePattern.h.

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

                           {
    return _blocksize_spec.extent(dimension);
  }

blockspec()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

const BlockSpec_t& dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::blockspec ( ) const

inline

Cartesian arrangement of pattern blocks.

Definition at line 1252 of file ShiftTilePattern.h.

Referenced by dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::ndim().

  {
    return _blockspec;
  }

capacity()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

IndexType dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::capacity ( ) const

inline

The maximum number of elements arranged in this pattern.

See also

Pattern Concept

Definition at line 1332 of file ShiftTilePattern.h.

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

                                    {
    return _memory_layout.size();
  }

coords() [1/2]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

std::array<IndexType, NumDimensions> dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::coords ( IndexType  index ) const

inline

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

See also

Pattern Concept

Parameters

index

Global index (offset) to convert

Definition at line 1394 of file ShiftTilePattern.h.

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

Referenced by dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local().

                           {

    ::std::array<IndexType, NumDimensions> pos{};
    auto block_coords = _blockspec.coords(index / _blocksize_spec.size());
    auto phase_coords = _blocksize_spec.coords(index % _blocksize_spec.size());
    for (auto d = 0; d < NumDimensions; ++d) {
      pos[d] = block_coords[d]*_blocksize_spec.extent(d) + phase_coords[d];
    }
    return pos;
  }

coords() [2/2]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

std::array<IndexType, NumDimensions> dash::ShiftTilePattern< NumDimensions, 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

Parameters

index	Global index (offset) to convert
viewspec	View specification (offsets) to apply on coords

Definition at line 1413 of file ShiftTilePattern.h.

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

                                       {

    ::std::array<IndexType, NumDimensions> pos;
    auto block_coords = _blockspec.coords(index / _blocksize_spec.size(),
                                          viewspec);
    auto phase_coords = _blocksize_spec.coords(index % _blocksize_spec.size(),
                                               viewspec);
    for (auto d = 0; d < NumDimensions; ++d) {
      pos[d] = block_coords[d]*_blocksize_spec.extent(d) + phase_coords[d];
    }
    return pos;
  }

distspec()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

const DistributionSpec_t& dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::distspec ( ) const

inline

Distribution specification of this pattern.

Definition at line 1356 of file ShiftTilePattern.h.

Referenced by dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::ndim().

                                                     {
    return _distspec;
  }

extent()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

SizeType dash::ShiftTilePattern< NumDimensions, 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 535 of file ShiftTilePattern.h.

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

                                   {
    if (dim >= NumDimensions || dim < 0) {
      DASH_THROW(
        dash::exception::OutOfRange,
        "Wrong dimension for ShiftTilePattern::local_extent. "
        << "Expected dimension between 0 and " << NumDimensions-1 << ", "
        << "got " << dim);
    }
    return _memory_layout.extent(dim);
  }

extents()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

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

inline

Size specification of the index space mapped by this pattern.

See also

Pattern Concept

Definition at line 1374 of file ShiftTilePattern.h.

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

Referenced by dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::block(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local_block(), and dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local_block_local().

                                                            {
    return _memory_layout.extents();
  }

global() [1/3]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

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

Referenced by dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::global(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local_block(), and dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::ndim().

                                                                     {
    DASH_LOG_DEBUG("ShiftTilePattern.global()",
                   "unit:",    unit,
                   "lcoords:", local_coords);
    // Global coordinate of local element:
    std::array<IndexType, NumDimensions> global_coords = local_coords;
    // Local block coordinate of local element:
    auto blocksize_maj     = _blocksize_spec.extent(_major_tiled_dim);
    auto blocksize_min     = _blocksize_spec.extent(_minor_tiled_dim);
    auto l_block_coord_maj = local_coords[_major_tiled_dim] /
                               blocksize_maj;
    auto l_block_coord_min = (NumDimensions > 1)
                             ? local_coords[_minor_tiled_dim] /
                               blocksize_min
                             : 0;
    DASH_LOG_TRACE("ShiftTilePattern.global",
                   "minor tiled dim:",   _minor_tiled_dim,
                   "major tiled dim:",   _major_tiled_dim,
                   "l_block_coord_min:", l_block_coord_min,
                   "l_block_coord_maj:", l_block_coord_maj);
    // Apply diagonal shift in major tiled dimension:
    auto num_shift_blocks = (_nunits + unit -
                              (l_block_coord_min % _nunits))
                            % _nunits;
    num_shift_blocks     += _nunits * l_block_coord_maj;
    DASH_LOG_TRACE("ShiftTilePattern.global",
                   "num_shift_blocks:", num_shift_blocks,
                   "blocksize_maj:",    blocksize_maj);
    global_coords[_major_tiled_dim] =
      (num_shift_blocks * blocksize_maj) +
      local_coords[_major_tiled_dim] % blocksize_maj;
    DASH_LOG_DEBUG_VAR("ShiftTilePattern.global >", global_coords);
    return global_coords;
  }

global() [2/3]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

std::array<IndexType, NumDimensions> dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::global ( const std::array< IndexType, NumDimensions > &  local_coords ) const

inline

Converts local coordinates of a active unit to global coordinates.

See also

Pattern Concept

Definition at line 789 of file ShiftTilePattern.h.

References dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::global(), and dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local_coords().

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

global() [3/3]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

IndexType dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::global ( IndexType  local_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 803 of file ShiftTilePattern.h.

References dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::coords(), dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::extent(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::global(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::global_at(), dash::myid(), dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::size(), and dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::team().

  {
    DASH_LOG_TRACE("ShiftTilePattern.global()",
                   "local_index:", local_index,
                   "unit:",        team().myid());
    auto block_size    = _blocksize_spec.size();
    auto phase         = local_index % block_size;
    auto l_block_index = local_index / block_size;
    // Block coordinate in local memory:
    auto l_block_coord = _local_blockspec.coords(l_block_index);
    // Coordinate of element in block:
    auto phase_coord   = _blocksize_spec.coords(phase);
    DASH_LOG_TRACE("ShiftTilePattern.global",
                   "local block index:",  l_block_index,
                   "local block coords:", l_block_coord,
                   "phase coords:",       phase_coord);
    // Coordinate of element in local memory:
    std::array<IndexType, NumDimensions> l_coords{};
    for (auto d = 0; d < NumDimensions; ++d) {
      l_coords[d] = l_block_coord[d] * _blocksize_spec.extent(d) +
                    phase_coord[d];
    }
    std::array<IndexType, NumDimensions> g_coords =
      global(team().myid(), l_coords);
    auto offset = global_at(g_coords);
    DASH_LOG_TRACE_VAR("ShiftTilePattern.global >", offset);
    return offset;
  }

global_at() [1/2]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

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

inline

Global coordinates and viewspec to global position in the pattern's iteration order.

NOTE: Expects extent[d] to be a multiple of blocksize[d] * nunits[d] to ensure the balanced property.

See also

at

local_at

Pattern Concept

Definition at line 869 of file ShiftTilePattern.h.

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

Referenced by dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::global().

  {
    DASH_LOG_TRACE("ShiftTilePattern.global_at()",
                   "gcoords:",  global_coords,
                   "viewspec:", viewspec);
    // Phase coordinates of element:
    std::array<IndexType, NumDimensions> phase_coords{};
    // Coordinates of the block containing the element:
    std::array<IndexType, NumDimensions> block_coords{};
    for (auto d = 0; d < NumDimensions; ++d) {
      auto vs_coord     = global_coords[d] + viewspec.offset(d);
      phase_coords[d]   = vs_coord % _blocksize_spec.extent(d);
      block_coords[d]   = vs_coord / _blocksize_spec.extent(d);
    }
    DASH_LOG_TRACE("ShiftTilePattern.global_at",
                   "block coords:", block_coords,
                   "phase coords:", phase_coords);
    // Number of blocks preceeding the coordinates' block, equivalent
    // to linear global block offset:
    auto block_index = _blockspec.at(block_coords);
    DASH_LOG_TRACE("ShiftTilePattern.global_at",
                   "block index:",   block_index);
    auto offset = block_index * _blocksize_spec.size() + // preceed. blocks
                  _blocksize_spec.at(phase_coords);      // element phase
    DASH_LOG_TRACE_VAR("ShiftTilePattern.global_at >", offset);
    return offset;
  }

global_at() [2/2]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

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

inline

Global coordinates to global position in the pattern's iteration order.

NOTE: Expects extent[d] to be a multiple of blocksize[d] * nunits[d] to ensure the balanced property.

See also

at

local_at

Pattern Concept

Definition at line 911 of file ShiftTilePattern.h.

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

  {
    DASH_LOG_TRACE("ShiftTilePattern.global_at()",
                   "gcoords:",  global_coords);
    // Phase coordinates of element:
    std::array<IndexType, NumDimensions> phase_coords;
    // Coordinates of the block containing the element:
    std::array<IndexType, NumDimensions> block_coords;
    for (auto d = 0; d < NumDimensions; ++d) {
      auto vs_coord     = global_coords[d];
      phase_coords[d]   = vs_coord % _blocksize_spec.extent(d);
      block_coords[d]   = vs_coord / _blocksize_spec.extent(d);
    }
    DASH_LOG_TRACE("ShiftTilePattern.global_at",
                   "block coords:", block_coords,
                   "phase coords:", phase_coords);
    // Number of blocks preceeding the coordinates' block, equivalent
    // to linear global block offset:
    auto block_index = _blockspec.at(block_coords);
    DASH_LOG_TRACE("ShiftTilePattern.global_at",
                   "block index:",   block_index);
    auto offset = block_index * _blocksize_spec.size() + // preceed. blocks
                  _blocksize_spec.at(phase_coords);      // element phase
    DASH_LOG_TRACE_VAR("ShiftTilePattern.global_at >", offset);
    return offset;
  }

global_index()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

IndexType dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::global_index ( team_unit_t  unit, const std::array< IndexType, NumDimensions > &  local_coords  ) const

inline

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

See also

at

global_at

Pattern Concept

Definition at line 842 of file ShiftTilePattern.h.

  {
    DASH_LOG_TRACE("ShiftTilePattern.global_index()",
                   "unit:",         unit,
                   "local_coords:", local_coords);
    std::array<IndexType, NumDimensions> global_coords =
      global(unit, local_coords);
    auto g_index = global_at(global_coords);
    DASH_LOG_TRACE_VAR("ShiftTilePattern.global_index >", g_index);
    return g_index;
  }

has_local_elements()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

bool dash::ShiftTilePattern< NumDimensions, 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	team-local id of the unit
viewspec	Viewspec to apply

Definition at line 1055 of file ShiftTilePattern.h.

  {
    DASH_LOG_TRACE_VAR("ShiftTilePattern.has_local_elements()", dim);
    DASH_LOG_TRACE_VAR("ShiftTilePattern.has_local_elements()", dim_offset);
    DASH_LOG_TRACE_VAR("ShiftTilePattern.has_local_elements()", unit);
    DASH_LOG_TRACE_VAR("ShiftTilePattern.has_local_elements()", viewspec);
    // Apply viewspec offset in dimension to given position
    dim_offset += viewspec.offset(dim);
    // Offset to block offset
    IndexType block_coord_d    = dim_offset / _blocksize_spec.extent(dim);
    DASH_LOG_TRACE_VAR("ShiftTilePattern.has_local_elements", block_coord_d);
    // Coordinate of unit in team spec in given dimension
    IndexType teamspec_coord_d = block_coord_d % _teamspec.extent(dim);
    DASH_LOG_TRACE_VAR("ShiftTilePattern.has_local_elements",
                       teamspec_coord_d);
    // Check if unit id lies in cartesian sub-space of team spec
    return _teamspec.includes_index(
              teamspec_coord_d,
              dim,
              dim_offset);
  }

is_local() [1/2]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

bool dash::ShiftTilePattern< NumDimensions, 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 1090 of file ShiftTilePattern.h.

Referenced by dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::is_local().

  {
    auto glob_coords = coords(index);
    auto coords_unit = unit_at(glob_coords);
    DASH_LOG_TRACE_VAR("ShiftTilePattern.is_local >", (coords_unit == unit));
    return coords_unit == unit;
  }

is_local() [2/2]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

bool dash::ShiftTilePattern< NumDimensions, 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 1106 of file ShiftTilePattern.h.

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

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

lbegin()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

IndexType dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::lbegin ( ) const

inline

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

See also

Pattern Concept

Definition at line 425 of file ShiftTilePattern.h.

                           {
    return _lbegin;
  }

lend()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

IndexType dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::lend ( ) const

inline

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

See also

Pattern Concept

Definition at line 434 of file ShiftTilePattern.h.

                         {
    return _lend;
  }

local() [1/2]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

local_coords_t dash::ShiftTilePattern< NumDimensions, 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 667 of file ShiftTilePattern.h.

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

  {
    local_coords_t l_coords;
    l_coords.coords = local_coords(global_coords);
    l_coords.unit   = unit_at(global_coords);
    return l_coords;
  }

local() [2/2]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

local_index_t dash::ShiftTilePattern< NumDimensions, 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 683 of file ShiftTilePattern.h.

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

  {
    DASH_LOG_TRACE_VAR("ShiftTilePattern.local()", g_index);
    // TODO: Implement dedicated method for this, conversion to/from
    //       global coordinates is expensive.
    auto g_coords = coords(g_index);
    return local_index(g_coords);
  }

local_at() [1/2]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

IndexType dash::ShiftTilePattern< NumDimensions, 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 (local offsets) to apply on local_coords

Definition at line 594 of file ShiftTilePattern.h.

References dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::at(), dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::extent(), dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::extents(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local_index(), and dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::size().

  {
    DASH_LOG_TRACE("ShiftTilePattern.local_at()", local_coords,
                   "view:",         viewspec,
                   "local blocks:", _local_blockspec.extents());
    // Phase coordinates of element:
    std::array<IndexType, NumDimensions> phase_coords{};
    // Coordinates of the local block containing the element:
    std::array<IndexType, NumDimensions> block_coords_l{};
    for (auto d = 0; d < NumDimensions; ++d) {
      auto vs_offset_d  = viewspec.offset(d);
      auto vs_coord_d   = local_coords[d] + vs_offset_d;
      auto block_size_d = _blocksize_spec.extent(d);
      phase_coords[d]   = vs_coord_d % block_size_d;
      block_coords_l[d] = vs_coord_d / block_size_d;
    }
    DASH_LOG_TRACE("ShiftTilePattern.local_at",
                   "local block coords:", block_coords_l,
                   "phase coords:",       phase_coords);
    // Number of blocks preceeding the coordinates' block:
    auto block_offset_l = _local_blockspec.at(block_coords_l);
    auto local_index    =
           block_offset_l * _blocksize_spec.size() + // preceeding blocks
           _blocksize_spec.at(phase_coords);         // element phase
    DASH_LOG_TRACE_VAR("ShiftTilePattern.local_at >", local_index);
    return local_index;
  }

local_at() [2/2]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

IndexType dash::ShiftTilePattern< NumDimensions, 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 631 of file ShiftTilePattern.h.

References dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::at(), dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::extent(), dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::extents(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local_index(), and dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::size().

  {
    DASH_LOG_TRACE("ShiftTilePattern.local_at()", local_coords,
                   "local blocks:", _local_blockspec.extents());
    // Phase coordinates of element:
    std::array<IndexType, NumDimensions> phase_coords{};
    // Coordinates of the local block containing the element:
    std::array<IndexType, NumDimensions> block_coords_l{};
    for (auto d = 0; d < NumDimensions; ++d) {
      auto vs_coord_d   = local_coords[d];
      auto block_size_d = _blocksize_spec.extent(d);
      phase_coords[d]   = vs_coord_d % block_size_d;
      block_coords_l[d] = vs_coord_d / block_size_d;
    }
    DASH_LOG_TRACE("ShiftTilePattern.local_at",
                   "local block coords:", block_coords_l,
                   "phase coords:",       phase_coords);
    // Number of blocks preceeding the coordinates' block:
    auto block_offset_l = _local_blockspec.at(block_coords_l);
    auto local_index    =
           block_offset_l * _blocksize_spec.size() + // preceeding blocks
           _blocksize_spec.at(phase_coords);         // element phase
    DASH_LOG_TRACE_VAR("ShiftTilePattern.local_at >", local_index);
    return local_index;
  }

local_block()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

ViewSpec_t dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local_block ( index_type  local_block_index ) const

inline

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

Definition at line 1182 of file ShiftTilePattern.h.

References dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::coords(), dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::extent(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::extents(), and dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::global().

                                        {
    DASH_LOG_TRACE_VAR("ShiftTilePattern.local_block()", local_block_index);
    // Local block index to local block coords:
    auto l_block_coords = _local_blockspec.coords(local_block_index);
    DASH_LOG_TRACE_VAR("ShiftTilePattern.local_block()", l_block_coords);
    std::array<index_type, NumDimensions> l_elem_coords{};
    // TODO: This is convenient but less efficient:
    // Translate local coordinates of first element in local block to global
    // coordinates:
    for (auto d = 0; d < NumDimensions; ++d) {
      auto blocksize_d = _blocksize_spec.extent(d);
      l_elem_coords[d] = static_cast<index_type>(
                           l_block_coords[d] * blocksize_d);
    }
    // Global coordinates of first element in block:
    auto g_elem_coords = global(l_elem_coords);
    DASH_LOG_TRACE_VAR("ShiftTilePattern.local_block()", g_elem_coords);
    std::array<index_type, NumDimensions> offsets{};
    std::array<size_type, NumDimensions>  extents{};
    for (auto d = 0; d < NumDimensions; ++d) {
      offsets[d] = g_elem_coords[d];
      extents[d] = _blocksize_spec.extent(d);
    }
    ViewSpec_t block_vs(offsets, extents);
    DASH_LOG_TRACE_VAR("ShiftTilePattern.local_block >", block_vs);
#ifdef __TODO__
    // Coordinates of the unit within the team spec:
    std::array<IndexType, NumDimensions> unit_ts_coord =
      _teamspec.coords(unit);
    for (auto d = 0; d < NumDimensions; ++d) {
      const Distribution & dist = _distspec[d];
      auto blocksize_d          = block_vs[d].extent;
      auto num_units_d          = _teamspec.extent(d);
      auto num_blocks_d         = _blockspec.extent(d);
      // Local to global block coords:
      auto g_block_coord_d      = (l_block_coords[d] + _myid) *
                                  _teamspec.extent(d);
      block_vs[d].offset        = g_block_coord_d * blocksize_d;
    }
#endif
    return block_vs;
  }

local_block_at()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

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

inline

Unit and local block index at given global coordinates.

See also

Pattern Concept

Parameters

g_coords

Global coordinates of element

Definition at line 1143 of file ShiftTilePattern.h.

  {
    DASH_THROW(
      dash::exception::NotImplemented,
      "ShiftTilePattern.local_block_at is not implemented");
  }

local_block_local()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

ViewSpec_t dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local_block_local ( index_type  local_block_index ) const

inline

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

Definition at line 1230 of file ShiftTilePattern.h.

References dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::coords(), dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::extents(), and dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::extents().

                                        {
    DASH_LOG_TRACE_VAR("ShiftTilePattern.local_block_local()", local_block_index);
    // Initialize viewspec result with block extents:
    std::array<index_type, NumDimensions> offsets{};
    std::array<size_type, NumDimensions>  extents =
      _blocksize_spec.extents();
    // Local block index to local block coords:
    auto l_block_coords = _local_blockspec.coords(local_block_index);
    // Local block coords to local element offset:
    for (auto d = 0; d < NumDimensions; ++d) {
      auto blocksize_d  = extents[d];
      offsets[d]        = l_block_coords[d] * blocksize_d;
    }
    ViewSpec_t block_vs(offsets, extents);
    DASH_LOG_TRACE_VAR("ShiftTilePattern.local_block >", block_vs);
    return block_vs;
  }

local_blockspec()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

const BlockSpec_t& dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local_blockspec ( ) const

inline

Cartesian arrangement of pattern blocks.

Definition at line 1260 of file ShiftTilePattern.h.

  {
    return _local_blockspec;
  }

local_capacity()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

SizeType dash::ShiftTilePattern< NumDimensions, 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 1296 of file ShiftTilePattern.h.

References dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local_size().

                                         {
    // Balanced pattern, local capacity identical for every unit and
    // same as local size.
    return local_size();
  }

local_coords()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

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

inline

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

See also

Pattern Concept

Definition at line 699 of file ShiftTilePattern.h.

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

Referenced by dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::global(), and dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local().

  {
    std::array<IndexType, NumDimensions> local_coords = global_coords;
    auto blocksize_d = _blocksize_spec.extent(_major_tiled_dim);
    auto coord_d     = global_coords[_major_tiled_dim];
    local_coords[_major_tiled_dim] =
      // Local block offset
      (coord_d / (blocksize_d * _nunits)) * blocksize_d +
      // Phase
      (coord_d % blocksize_d);
    return local_coords;
  }

local_extent()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

SizeType dash::ShiftTilePattern< NumDimensions, 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 557 of file ShiftTilePattern.h.

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

                                         {
    if (dim >= NumDimensions || dim < 0) {
      DASH_THROW(
        dash::exception::OutOfRange,
        "Wrong dimension for ShiftTilePattern::local_extent. "
        << "Expected dimension between 0 and " << NumDimensions-1 << ", "
        << "got " << dim);
    }
    return _local_memory_layout.extent(dim);
  }

local_extents()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

std::array<SizeType, NumDimensions> dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local_extents ( ) 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 579 of file ShiftTilePattern.h.

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

                                                          {
    // Same local memory layout for all units:
    return _local_memory_layout.extents();
  }

local_index()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

local_index_t dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local_index ( const std::array< IndexType, NumDimensions > &  global_coords ) const

inline

Resolves the unit and the local index from global coordinates.

See also

Pattern Concept

Definition at line 718 of file ShiftTilePattern.h.

Referenced by dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local(), and dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local_at().

  {
    DASH_LOG_TRACE_VAR("Pattern.local_index()", global_coords);
    // Local offset of the element within all of the unit's local
    // elements:
    auto unit = unit_at(global_coords);
#ifdef __OLD__
    // Global coords to local coords:
    std::array<IndexType, NumDimensions> l_coords =
      local_coords(global_coords);
    // Local coords to local offset:
    auto l_index = local_at(l_coords);
#endif
    auto l_index = at(global_coords);
    DASH_LOG_TRACE_VAR("Pattern.local_index >", l_index);

    return local_index_t { team_unit_t(unit), l_index };
  }

local_size()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

SizeType dash::ShiftTilePattern< NumDimensions, 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 1312 of file ShiftTilePattern.h.

Referenced by dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local_capacity(), and dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::ndim().

  {
    return _local_memory_layout.size();
  }

max_blocksize()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

SizeType dash::ShiftTilePattern< NumDimensions, 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 1286 of file ShiftTilePattern.h.

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

                                        {
    return _blocksize_spec.size();
  }

memory_order()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

static constexpr MemArrange dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::memory_order ( )

inlinestatic

Memory order followed by the pattern.

Definition at line 1433 of file ShiftTilePattern.h.

                                             {
    return Arrangement;
  }

ndim()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

static constexpr dim_t dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::ndim ( )

inlinestatic

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

Definition at line 1440 of file ShiftTilePattern.h.

References dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::blockspec(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::distspec(), dash::CartesianSpace< NumDimensions, SizeType >::extent(), dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::extent(), dash::CartesianSpace< NumDimensions, SizeType >::extents(), dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::extents(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::global(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local_size(), dash::Distribution::max_blocksize_in_range(), dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::ShiftTilePattern(), dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::size(), and dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::size().

                                {
    return NumDimensions;
  }

num_units()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

IndexType dash::ShiftTilePattern< NumDimensions, 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 1323 of file ShiftTilePattern.h.

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

                                     {
    return _teamspec.size();
  }

operator!=()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

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

inline

Inquality comparison operator.

Parameters

other

ShiftTilePattern instance to compare for inequality

Definition at line 390 of file ShiftTilePattern.h.

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

operator=()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

ShiftTilePattern& dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::operator= ( const ShiftTilePattern< NumDimensions, Arrangement, IndexType > &  other )

inline

Assignment operator.

Definition at line 400 of file ShiftTilePattern.h.

                                                               {
    if (this != &other) {
      _distspec            = other._distspec;
      _team                = other._team;
      _teamspec            = other._teamspec;
      _memory_layout       = other._memory_layout;
      _local_memory_layout = other._local_memory_layout;
      _blocksize_spec      = other._blocksize_spec;
      _blockspec           = other._blockspec;
      _local_blockspec     = other._local_blockspec;
      _local_capacity      = other._local_capacity;
      _nunits              = other._nunits;
      _minor_tiled_dim     = other._minor_tiled_dim;
      _major_tiled_dim     = other._major_tiled_dim;
      _lbegin              = other._lbegin;
      _lend                = other._lend;
    }
    return *this;
  }

operator==()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

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

inline

Equality comparison operator.

Parameters

other

ShiftTilePattern instance to compare for equality

Definition at line 368 of file ShiftTilePattern.h.

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

size()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

IndexType dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::size ( ) const

inline

The number of elements arranged in this pattern.

See also

Pattern Concept

Definition at line 1341 of file ShiftTilePattern.h.

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

Referenced by dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::ndim().

                                {
    return _memory_layout.size();
  }

sizespec()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

SizeSpec_t dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::sizespec ( ) const

inline

Size specification of the index space mapped by this pattern.

See also

Pattern Concept

Definition at line 1365 of file ShiftTilePattern.h.

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

                              {
    return SizeSpec_t(_memory_layout.extents());
  }

team()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

dash::Team& dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::team ( ) const

inline

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

Definition at line 1349 of file ShiftTilePattern.h.

Referenced by dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::global(), and dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::is_local().

                                 {
    return *_team;
  }

teamspec()

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

const TeamSpec_t& dash::ShiftTilePattern< NumDimensions, 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 1384 of file ShiftTilePattern.h.

                                      {
    return _teamspec;
  }

unit_at() [1/4]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

team_unit_t dash::ShiftTilePattern< NumDimensions, 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 relative to the given view.
viewspec	View specification (offsets) of the coordinates.

Definition at line 447 of file ShiftTilePattern.h.

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

Referenced by dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::local(), and dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::unit_at().

  {
    DASH_LOG_TRACE("ShiftTilePattern.unit_at()",
                   "coords:",   coords,
                   "viewspec:", viewspec);
    // Unit id from diagonals in cartesian index space,
    // e.g (x + y + z) % nunits
    team_unit_t unit_id{0};
    for (auto d = 0; d < NumDimensions; ++d) {
      auto vs_coord     = coords[d] + viewspec.offset(d);
      // Global block coordinate:
      auto block_coord  = vs_coord / _blocksize_spec.extent(d);
      unit_id          += block_coord;
    }
    unit_id %= _nunits;
    DASH_LOG_TRACE_VAR("ShiftTilePattern.unit_at >", unit_id);
    return unit_id;
  }

unit_at() [2/4]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

team_unit_t dash::ShiftTilePattern< NumDimensions, 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 475 of file ShiftTilePattern.h.

References dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::extent(), and dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::extents().

  {
    DASH_LOG_TRACE("ShiftTilePattern.unit_at()",
                   "coords:",    coords,
                   "blocksize:", _blocksize_spec.extents());
    // Unit id from diagonals in cartesian index space,
    // e.g (x + y + z) % nunits
    team_unit_t unit_id{0};
    for (auto d = 0; d < NumDimensions; ++d) {
      // Global block coordinate:
      auto block_coord  = coords[d] / _blocksize_spec.extent(d);
      unit_id          += block_coord;
    }
    unit_id %= _nunits;
    DASH_LOG_TRACE_VAR("ShiftTilePattern.unit_at >", unit_id);
    return unit_id;
  }

unit_at() [3/4]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

team_unit_t dash::ShiftTilePattern< NumDimensions, 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 499 of file ShiftTilePattern.h.

References dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::coords(), and dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::unit_at().

  {
    auto global_coords = _memory_layout.coords(global_pos);
    return unit_at(global_coords, viewspec);
  }

unit_at() [4/4]

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

team_unit_t dash::ShiftTilePattern< NumDimensions, 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 514 of file ShiftTilePattern.h.

References dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::coords(), and dash::ShiftTilePattern< NumDimensions, Arrangement, IndexType >::unit_at().

  {
    auto global_coords = _memory_layout.coords(global_pos);
    return unit_at(global_coords);
  }

---

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

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