dash::TeamSpec< MaxDimensions, IndexType > Class Template Reference

Specifies the arrangement of team units in a specified number of dimensions. More...

#include <TeamSpec.h>

Public Types
typedef IndexType	index_type
typedef SizeType	size_type
typedef std::array< SizeType, NumDimensions >	extents_type
typedef std::integral_constant< dim_t, NumDimensions >	ndim
	The number of dimension in the cartesian space. More...

Public Member Functions
	TeamSpec (Team &team=dash::Team::All())
	Constructor, creates an instance of TeamSpec from a team (set of units) with all team units organized linearly in the first dimension. More...
	TeamSpec (const self_t &other, const DistributionSpec< MaxDimensions > &distribution, Team &team=dash::Team::All())
	Constructor, creates an instance of TeamSpec with given extents from a team (set of units) and a distribution spec. More...
	TeamSpec (const DistributionSpec< MaxDimensions > &distribution, Team &team=dash::Team::All())
	Constructor, creates an instance of TeamSpec from a team (set of units) and a distribution spec. More...
template<typename ... Types>
	TeamSpec (SizeType value, Types ... values)
	Constructor, initializes new instance of TeamSpec with extents specified in argument list. More...
	TeamSpec (const std::array< SizeType, MaxDimensions > &extents)
	Constructor, initializes new instance of TeamSpec with extents specified in array by dimension. More...
void	balance_extents ()
	Tries to equally distribute the units across the dimensions. More...
team_unit_t	neighbor (std::initializer_list< int > offsets) const
	Resolve unit id at given offset in Cartesian team grid relative to the active unit's position in the team. More...
team_unit_t	neighbor (const std::array< int, MaxDimensions > &offsets) const
team_unit_t	periodic_neighbor (std::initializer_list< int > offsets) const
	Resolve unit id at given offset in Cartesian team grid relative to the active unit's position in the team. More...
team_unit_t	periodic_neighbor (const std::array< int, MaxDimensions > &offsets) const
bool	includes_index (IndexType index, dim_t dimension, IndexType dim_offset) const
	Whether the given index lies in the cartesian sub-space specified by a dimension and offset in the dimension. More...
SizeType	num_units (dim_t dimension) const
	The number of units (extent) available in the given dimension. More...
template<typename... Args>
void	resize (SizeType arg, Args... args)
	Change the extent of the cartesian space in every dimension. More...
template<typename SizeType_ >
void	resize (const std::array< SizeType_, MaxDimensions > &extents)
	Change the extent of the cartesian space in every dimension. More...
void	resize_dim (dim_t dim, SizeType extent)
	Change the extent of the cartesian space in the given dimension. More...
dim_t	rank () const
	The actual number of dimensions with extent greater than 1 in this team arragement, that is the dimension of the vector space spanned by the team arrangement's extents. More...
bool	operator== (const self_t &other) const
	Equality comparison operator. More...
constexpr bool	operator!= (const self_t &other) const
	Inequality comparison operator. More...
void	resize (const std::array< SizeType_, NumDimensions > &extents)
	Change the extent of the cartesian space in every dimension. More...
void	resize (dim_t dim, SizeType extent)
	Change the extent of the cartesian space in the given dimension. More...
constexpr SizeType	size () const noexcept
	The number of discrete elements within the space spanned by the coordinate. More...
constexpr const extents_type &	extents () const noexcept
	Extents of the cartesian space, by dimension. More...
SizeType	extent (dim_t dim) const
	The extent of the cartesian space in the given dimension. More...
constexpr IndexType	at (IndexType arg, Args... args) const
	Convert the given coordinates to their respective linear index. More...
IndexType	at (const std::array< OffsetType, NumDimensions > &point) const
	Convert the given cartesian point to its respective linear index. More...
IndexType	at (const std::array< OffsetType, NumDimensions > &point, const ViewSpec_t &viewspec) const
	Convert the given cartesian point to a linear index, respective to the offsets specified in the given ViewSpec. More...
std::array< IndexType, NumDimensions >	coords (IndexType index) const
	Convert given linear offset (index) to cartesian coordinates. More...
std::array< IndexType, NumDimensions >	coords (IndexType index, const ViewSpec_t &viewspec) const
	Convert given linear offset (index) to cartesian coordinates with respect to a given viewspec. More...
constexpr std::enable_if<(U > 0), SizeType >::type	x (SizeType offs) const
	Accessor for dimension 1 (x), enabled for dimensionality > 0. More...
constexpr std::enable_if<(U > 1), SizeType >::type	y (SizeType offs) const
	Accessor for dimension 2 (y), enabled for dimensionality > 1. More...
constexpr std::enable_if<(U > 2), SizeType >::type	z (SizeType offs) const
	Accessor for dimension 3 (z), enabled for dimensionality > 2. More...

Detailed Description

template<dim_t MaxDimensions, typename IndexType = dash::default_index_t>
class dash::TeamSpec< MaxDimensions, IndexType >

Specifies the arrangement of team units in a specified number of dimensions.

Size of TeamSpec implies the number of units in the team.

Reoccurring units are currently not supported.

Template Parameters

NumDimensions

Number of dimensions

Examples:

ex.06.pattern-block-visualizer/main.cpp, ex.11.halo-stencil/main.cpp, and ex.11.simple-stencil/main.cpp.

Definition at line 33 of file TeamSpec.h.

Member Typedef Documentation

ndim

typedef std::integral_constant<dim_t, NumDimensions> dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::ndim

inherited

The number of dimension in the cartesian space.

Definition at line 279 of file Cartesian.h.

Constructor & Destructor Documentation

TeamSpec() [1/5]

template<dim_t MaxDimensions, typename IndexType = dash::default_index_t>

dash::TeamSpec< MaxDimensions, IndexType >::TeamSpec ( Team &  team = dash::Team::All() )

inline

Constructor, creates an instance of TeamSpec from a team (set of units) with all team units organized linearly in the first dimension.

Definition at line 50 of file TeamSpec.h.

  : _is_linear(true),
    _myid(team.myid())
  {
    DASH_LOG_TRACE_VAR("TeamSpec(t)", team.is_null());
    auto team_size = team.is_null() ? 0 : team.size();
    _rank = 1;
    this->_extents[0] = team_size;
    for (auto d = 1; d < MaxDimensions; ++d) {
      this->_extents[d] = 1;
    }
    this->resize(this->_extents);
  }

TeamSpec() [2/5]

template<dim_t MaxDimensions, typename IndexType = dash::default_index_t>

dash::TeamSpec< MaxDimensions, IndexType >::TeamSpec ( const self_t &  other, const DistributionSpec< MaxDimensions > &  distribution, Team &  team = dash::Team::All()  )

inline

Constructor, creates an instance of TeamSpec with given extents from a team (set of units) and a distribution spec.

The number of elements in the distribution different from NONE must be equal to the rank of the extents.

This constructor adjusts extents according to given distribution spec if the passed team spec has been default constructed.

Example:

TeamSpec<2> ts(
  // default-constructed, extents: [Team::All().size(), 1]
  TeamSpec<2>(),
  // distributed in dimension 1 (y)
  DistSpec<2>(NONE, BLOCKED),
  Team::All().split(2));
// Will be adjusted to:
size_t units_x = ts.extent(0); // -> 1
size_t units_y = ts.extent(1); // -> Team::All().size() / 2

Definition at line 88 of file TeamSpec.h.

  : CartesianIndexSpace<MaxDimensions, ROW_MAJOR, IndexType>(
      other.extents()),
      _myid(team.myid())
  {
    DASH_LOG_TRACE_VAR("TeamSpec(ts, dist, t)", team.is_null());
#if 0
    if (this->size() != team.size()) {
      DASH_THROW(
        dash::exception::InvalidArgument,
        "Size of team "     << team.size()  << " differs from " <<
        "size of teamspec " << this->size() << " in TeamSpec()");
    }
#endif
    // Test if other teamspec has been default-constructed and has
    // to be rearranged for a distribution with higher rank:
    if (other._is_linear && distribution.rank() > 1) {
      // Set extent of teamspec in the dimension the distribution is
      // different from NONE:
      if (distribution.is_tiled()) {
        bool major_tiled_dim_set = false;
        for (auto d = 0; d < MaxDimensions; ++d) {
          this->_extents[d] = 1;
          if (!major_tiled_dim_set &&
              distribution[d].type == dash::internal::DIST_TILE) {
            this->_extents[d] = team.size();
            major_tiled_dim_set = true;
          }
        }
      } else {
        for (auto d = 0; d < MaxDimensions; ++d) {
          if (distribution[d].type == dash::internal::DIST_NONE) {
            this->_extents[d] = 1;
          } else {
            // Use size of given team; possibly different from size
            // of default-constructed team spec:
            this->_extents[d] = team.size();
          }
        }
      }
    }
    update_rank();
    DASH_LOG_TRACE_VAR("TeamSpec(ts, dist, t)", this->_extents);
    this->resize(this->_extents);
    DASH_LOG_TRACE_VAR("TeamSpec(ts, dist, t)", this->size());
  }

TeamSpec() [3/5]

template<dim_t MaxDimensions, typename IndexType = dash::default_index_t>

dash::TeamSpec< MaxDimensions, IndexType >::TeamSpec ( const DistributionSpec< MaxDimensions > &  distribution, Team &  team = dash::Team::All()  )

inline

Constructor, creates an instance of TeamSpec from a team (set of units) and a distribution spec.

All but one element in the distribution spec must be NONE.

Definition at line 143 of file TeamSpec.h.

  : _myid(team.myid())
  {
    DASH_LOG_TRACE_VAR("TeamSpec(dist, t)", team.is_null());
    bool distrib_dim_set = false;
    if (distribution.is_tiled()) {
      bool major_tiled_dim_set = false;
      for (auto d = 0; d < MaxDimensions; ++d) {
        this->_extents[d] = 1;
        if (!major_tiled_dim_set &&
            distribution[d].type == dash::internal::DIST_TILE) {
          this->_extents[d] = team.size();
          major_tiled_dim_set = true;
        }
      }
    } else {
      for (auto d = 0; d < MaxDimensions; ++d) {
        if (distribution[d].type == dash::internal::DIST_NONE) {
          this->_extents[d] = 1;
        } else {
          this->_extents[d] = team.size();
          if (distrib_dim_set) {
            DASH_THROW(
              dash::exception::InvalidArgument,
              "TeamSpec(DistributionSpec, Team) only allows "
              "one distributed dimension");
          }
          distrib_dim_set = true;
        }
      }
    }
    update_rank();
    DASH_LOG_TRACE_VAR("TeamSpec(dist, t)", this->_extents);
    this->resize(this->_extents);
    DASH_LOG_TRACE_VAR("TeamSpec(dist, t)", this->size());
  }

TeamSpec() [4/5]

template<dim_t MaxDimensions, typename IndexType = dash::default_index_t>

template<typename ... Types>

dash::TeamSpec< MaxDimensions, IndexType >::TeamSpec ( SizeType  value, Types ...  values  )

inline

Constructor, initializes new instance of TeamSpec with extents specified in argument list.

Example:

TeamSpec<3> ts(1,2,3); // extents 1x2x3

Definition at line 193 of file TeamSpec.h.

  : CartesianIndexSpace<MaxDimensions, ROW_MAJOR, IndexType>::
      CartesianIndexSpace(value, values...),
      _myid(dash::Team::All().myid())
  {
    update_rank();
    this->resize(this->_extents);
    DASH_LOG_TRACE_VAR("TeamSpec(size,...)", this->_extents);
  }

TeamSpec() [5/5]

template<dim_t MaxDimensions, typename IndexType = dash::default_index_t>

dash::TeamSpec< MaxDimensions, IndexType >::TeamSpec ( const std::array< SizeType, MaxDimensions > &  extents )

inline

Constructor, initializes new instance of TeamSpec with extents specified in array by dimension.

Example:

TeamSpec<3> ts({ 1,2,3 }); // extents 1x2x3

Definition at line 213 of file TeamSpec.h.

  : CartesianIndexSpace<MaxDimensions, ROW_MAJOR, IndexType>::
      CartesianIndexSpace(extents),
      _myid(dash::Team::All().myid())
  {
    update_rank();
    this->resize(this->_extents);
    DASH_LOG_TRACE_VAR("TeamSpec({extents})", this->_extents);
  }

Member Function Documentation

at() [1/3]

constexpr IndexType dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::at ( IndexType  arg, Args...  args  ) const

inlineinherited

Convert the given coordinates to their respective linear index.

Parameters

args	An argument list consisting of the coordinates, ordered by, dimension (x, y, z, ...)

Definition at line 429 of file Cartesian.h.

Referenced by dash::TeamSpec< NumDimensions, IndexType >::neighbor(), and dash::TeamSpec< NumDimensions, IndexType >::periodic_neighbor().

                                         {
    static_assert(
      sizeof...(Args) == NumDimensions-1,
      "Invalid number of arguments");
    return at<AtArrangement>(
             std::array<IndexType, NumDimensions> {{
               arg, (IndexType)(args) ... }}
           );
  }

at() [2/3]

IndexType dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::at ( const std::array< OffsetType, NumDimensions > &  point ) const

inlineinherited

Convert the given cartesian point to its respective linear index.

Parameters

point

An array containing the coordinates, ordered by dimension (x, y, z, ...)

Definition at line 449 of file Cartesian.h.

                                                             {
    SizeType offs = 0;
    DASH_ASSERT_GT(_size, 0, "CartesianIndexSpace has size 0");
    for (auto i = 0; i < NumDimensions; i++) {
      DASH_ASSERT_RANGE(
        0,
        static_cast<IndexType>(point[i]),
        static_cast<IndexType>(_extents[i]-1),
        "Given coordinate for CartesianIndexSpace::at() exceeds extent");
      SizeType offset_dim = 0;
      if (AtArrangement == ROW_MAJOR) {
        offset_dim = _offset_row_major[i];
      } else if (AtArrangement == COL_MAJOR) {
        offset_dim = _offset_col_major[i];
      }
      offs += offset_dim * point[i];
    }
    return offs;
  }

at() [3/3]

IndexType dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::at ( const std::array< OffsetType, NumDimensions > &  point, const ViewSpec_t &  viewspec  ) const

inlineinherited

Convert the given cartesian point to a linear index, respective to the offsets specified in the given ViewSpec.

Parameters

point	An array containing the coordinates, ordered by dimension (x, y, z, ...)
viewspec	An instance of ViewSpec to apply to the given point before resolving the linear index.

Definition at line 482 of file Cartesian.h.

                                       {
    std::array<OffsetType, NumDimensions> coords{};
    for (auto d = 0; d < NumDimensions; ++d) {
      coords[d] = point[d] + viewspec.offset(d);
    }
    return at(coords);
  }

balance_extents()

template<dim_t MaxDimensions, typename IndexType = dash::default_index_t>

void dash::TeamSpec< MaxDimensions, IndexType >::balance_extents ( )

inline

Tries to equally distribute the units across the dimensions.

The number of units is determined by the current state of the extents.

Example:

TeamSpec<3> ts({ 21,2,3 }); // extents 21x2x3 == 126 units
ts.balance_extents();       // extents 7x6x3

Definition at line 234 of file TeamSpec.h.

  {
    DASH_LOG_TRACE_VAR("TeamSpec.balance_extents()", this->_extents);
    DASH_LOG_TRACE_VAR("TeamSpec.balance_extents()", this->size());
    if(MaxDimensions <= 1) {
      return;
    }

    std::multiset<SizeType> new_extents;

    SizeType num_units = 1;
    for (auto d = 0; d < MaxDimensions; ++d) {
      num_units *= this->_extents[d];
      this->_extents[d] = 1;
      new_extents.insert(1);
    }
    _is_linear = false;

    // Find best surface-to-volume:
    auto teamsize_prime_factors = dash::math::factorize(num_units);
    // Equally distribute factors to extents.
    // Start with the largest factors and multiply them onto the lowest
    // value.
    for (auto it = teamsize_prime_factors.rbegin();
         it != teamsize_prime_factors.rend();
         ++it) {
      DASH_LOG_TRACE("TeamSpec.balance_extents()",
                     "factor:", it->first, "x", it->second);
      for (auto i = 1; i < it->second + 1; ++i) {
        new_extents.insert(it->first * *new_extents.begin());
        new_extents.erase(new_extents.begin());
      }
    }

    int d = 0;
    for (auto it = new_extents.rbegin();
         it != new_extents.rend();
         ++it, ++d) {
      this->_extents[d] = *it;
    }

    this->resize(this->_extents);
    update_rank();
    DASH_LOG_TRACE_VAR("TeamSpec.balance_extents() ->", this->_extents);
  }

coords() [1/2]

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

inlineinherited

Convert given linear offset (index) to cartesian coordinates.

Inverse of at(...).

Definition at line 497 of file Cartesian.h.

Referenced by dash::TeamSpec< NumDimensions, IndexType >::neighbor(), and dash::TeamSpec< NumDimensions, IndexType >::periodic_neighbor().

  {
    DASH_ASSERT_GT(_size, 0, "CartesianIndexSpace has size 0");
    DASH_ASSERT_RANGE(
      0, index, static_cast<IndexType>(_size-1),
      "Given index for CartesianIndexSpace::coords() is out of bounds");

    ::std::array<IndexType, NumDimensions> pos{};
    if (CoordArrangement == ROW_MAJOR) {
      for(auto i = 0; i < NumDimensions; ++i) {
        pos[i] = index / _offset_row_major[i];
        index  = index % _offset_row_major[i];
      }
    } else if (CoordArrangement == COL_MAJOR) {
      for(auto i = NumDimensions-1; i >= 0; --i) {
        pos[i] = index / _offset_col_major[i];
        index  = index % _offset_col_major[i];
      }
    }
    return pos;
  }

coords() [2/2]

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

inlineinherited

Convert given linear offset (index) to cartesian coordinates with respect to a given viewspec.

Inverse of at(...).

Definition at line 526 of file Cartesian.h.

  {
    std::array<IndexType, NumDimensions> pos{};
    extents_type offset;
    if (CoordArrangement == ROW_MAJOR)
    {
      offset[NumDimensions-1] = 1;
      for(auto i = NumDimensions-2; i >= 0; --i)
        offset[i] = offset[i+1] * viewspec.extent(i+1);

      for(auto i = 0; i < NumDimensions; ++i)
      {
        pos[i] = index / offset[i] + viewspec.offset(i);
        index  = index % offset[i];
      }
    }
    else if (CoordArrangement == COL_MAJOR)
    {
      offset[0] = 1;
      for(auto i = 1; i < NumDimensions; ++i)
        offset[i] = offset[i-1] * viewspec.extent(i-1);

      for(auto i = NumDimensions-1; i >= 0; --i)
      {
        pos[i] = index / offset[i] + viewspec.offset(i);
        index  = index % offset[i];
      }
    }
    return pos;
  }

extent()

SizeType dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::extent ( dim_t  dim ) const

inlineinherited

The extent of the cartesian space in the given dimension.

Parameters

dim	The dimension in the coordinate

Returns

The extent in the given dimension

Definition at line 412 of file Cartesian.h.

Referenced by dash::TeamSpec< NumDimensions, IndexType >::num_units(), and dash::TeamSpec< NumDimensions, IndexType >::resize_dim().

                                   {
    DASH_ASSERT_RANGE(
      0, dim, NumDimensions-1,
      "Given dimension " << dim <<
      " for CartesianIndexSpace::extent(dim) is out of bounds");
    return _extents[dim];
  }

extents()

constexpr const extents_type& dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::extents ( ) const

inlinenoexceptinherited

Extents of the cartesian space, by dimension.

Definition at line 402 of file Cartesian.h.

Referenced by dash::TeamSpec< NumDimensions, IndexType >::resize().

                                                          {
    return _extents;
  }

includes_index()

template<dim_t MaxDimensions, typename IndexType = dash::default_index_t>

bool dash::TeamSpec< MaxDimensions, IndexType >::includes_index ( IndexType  index, dim_t  dimension, IndexType  dim_offset  ) const

inline

Whether the given index lies in the cartesian sub-space specified by a dimension and offset in the dimension.

Definition at line 385 of file TeamSpec.h.

  {
    if (_rank == 1) {
      // Shortcut for trivial case
      return (index >= 0 && index < this->size());
    }
    return parent_t::includes_index(index, dimension, dim_offset);
  }

neighbor()

template<dim_t MaxDimensions, typename IndexType = dash::default_index_t>

team_unit_t dash::TeamSpec< MaxDimensions, IndexType >::neighbor ( std::initializer_list< int >  offsets ) const

inline

Resolve unit id at given offset in Cartesian team grid relative to the active unit's position in the team.

Example:

TeamSpec<2> teamspec(7,4);
// west neighbor is offset -1 in column dimension:
team_unit_t neighbor_west = teamspec.neigbor({ 0, -1 });
// second south neighbor is offset -2 in row dimension:
team_unit_t neighbor_west = teamspec.neigbor({ -2, 0 });

Returns

The unit id at given offset in the team grid, relative to the active unit's position in the team, or DART_UNDEFINED_UNIT_ID if the offset is out of bounds.

Definition at line 298 of file TeamSpec.h.

Referenced by dash::TeamSpec< NumDimensions, IndexType >::neighbor().

  {
    auto neighbor_coords = this->coords(_myid);
    dim_t d = 0;
    for (auto offset_d : offsets) {
      neighbor_coords[d] += offset_d;
      if (neighbor_coords[d] < 0 ||
          neighbor_coords[d] >= this->_extents[d]) {
        return UNDEFINED_TEAM_UNIT_ID;
      }
      ++d;
    }
    return team_unit_t(static_cast<dart_unit_t>(this->at(neighbor_coords)));
  }

num_units()

template<dim_t MaxDimensions, typename IndexType = dash::default_index_t>

SizeType dash::TeamSpec< MaxDimensions, IndexType >::num_units ( dim_t  dimension ) const

inline

The number of units (extent) available in the given dimension.

Parameters

dimension

The dimension

Returns

The number of units in the given dimension

Definition at line 403 of file TeamSpec.h.

Referenced by dash::TeamSpec< NumDimensions, IndexType >::balance_extents().

  {
    return parent_t::extent(dimension);
  }

operator!=()

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

inlineinherited

Inequality comparison operator.

Definition at line 342 of file Cartesian.h.

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

operator==()

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

inlineinherited

Equality comparison operator.

Definition at line 322 of file Cartesian.h.

                                              {
    if (this == &other) {
      return true;
    }
    for(auto i = 0; i < NumDimensions; i++) {
      if (_extents[i] != other._extents[i]) {
        return false;
      }
      // Comparing either row- or column major offsets suffices:
      if (_offset_row_major[i] != other._offset_row_major[i]) {
        return false;
      }
    }
    // No need to compare _size as it is derived from _extents.
    return true;
  }

periodic_neighbor()

template<dim_t MaxDimensions, typename IndexType = dash::default_index_t>

team_unit_t dash::TeamSpec< MaxDimensions, IndexType >::periodic_neighbor ( std::initializer_list< int >  offsets ) const

inline

Resolve unit id at given offset in Cartesian team grid relative to the active unit's position in the team.

Offsets wrap around in every dimension as in a torus topology.

Example:

// assuming dash::myid() == 1, i.e. team spec coordinates are (0,1)
TeamSpec<2> teamspec(2,2);
// west neighbor is offset -1 in column dimension:
team_unit_t neighbor_west = teamspec.neigbor_periodic({ 0, -1 });
// -> unit 0
// second south neighbor at offset -2 in row dimension wraps around
// to row coordinate 0:
team_unit_t neighbor_west = teamspec.neigbor_periodic({ -2, 0 });
// -> unit 1

Returns

The unit id at given offset in the team grid, relative to the active unit's position in the team. If an offset is out of bounds, it is wrapped around in the respective dimension as in a torus topology.

Definition at line 350 of file TeamSpec.h.

Referenced by dash::TeamSpec< NumDimensions, IndexType >::periodic_neighbor().

  {
    auto neighbor_coords = this->coords(_myid);
    dim_t d = 0;
    for (auto offset_d : offsets) {
      neighbor_coords[d] += offset_d;
      if (neighbor_coords[d] < 0) {
        neighbor_coords[d] = this->_extents[d] + offset_d;
      } else if(neighbor_coords[d] >= this->_extents[d]) {
        neighbor_coords[d] %= this->_extents[d];
      }
      ++d;
    }
    return team_unit_t(static_cast<dart_unit_t>(this->at(neighbor_coords)));
  }

rank()

template<dim_t MaxDimensions, typename IndexType = dash::default_index_t>

dim_t dash::TeamSpec< MaxDimensions, IndexType >::rank ( ) const

inline

The actual number of dimensions with extent greater than 1 in this team arragement, that is the dimension of the vector space spanned by the team arrangement's extents.

Example:

TeamSpec<3> ts(1,2,3); // extents 1x2x3
ts.rank(); // returns 2, as one dimension has extent 1

Definition at line 454 of file TeamSpec.h.

  {
    return _rank;
  }

resize() [1/4]

void dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::resize ( const std::array< SizeType_, NumDimensions > &  extents )

inlineinherited

Change the extent of the cartesian space in every dimension.

Definition at line 363 of file Cartesian.h.

                                                                  {
    // Update size:
    _size = 1;
    for(auto i = 0; i < NumDimensions; i++ ) {
      _extents[i] = static_cast<SizeType>(extents[i]);
      _size      *= _extents[i];
    }
    // Update offsets:
    _offset_row_major[NumDimensions-1] = 1;
    for(auto i = NumDimensions-2; i >= 0; --i) {
      _offset_row_major[i] = _offset_row_major[i+1] * _extents[i+1];
    }
    _offset_col_major[0] = 1;
    for(auto i = 1; i < NumDimensions; ++i) {
      _offset_col_major[i] = _offset_col_major[i-1] * _extents[i-1];
    }
  }

resize() [2/4]

void dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::resize ( dim_t  dim, SizeType  extent  )

inlineinherited

Change the extent of the cartesian space in the given dimension.

Definition at line 384 of file Cartesian.h.

                                          {
    _extents[dim] = extent;
    resize(_extents);
  }

resize() [3/4]

template<dim_t MaxDimensions, typename IndexType = dash::default_index_t>

template<typename... Args>

void dash::TeamSpec< MaxDimensions, IndexType >::resize ( SizeType  arg, Args...  args  )

inline

Change the extent of the cartesian space in every dimension.

Definition at line 412 of file TeamSpec.h.

Referenced by dash::TeamSpec< NumDimensions, IndexType >::balance_extents(), dash::make_team_spec(), dash::TeamSpec< NumDimensions, IndexType >::resize(), dash::TeamSpec< NumDimensions, IndexType >::resize_dim(), and dash::TeamSpec< NumDimensions, IndexType >::TeamSpec().

  {
    static_assert(
      sizeof...(Args) == MaxDimensions-1,
      "Invalid number of arguments");
    std::array<SizeType, MaxDimensions> extents =
      {{ arg, (SizeType)(args)... }};
    resize(extents);
  }

resize() [4/4]

template<dim_t MaxDimensions, typename IndexType = dash::default_index_t>

template<typename SizeType_ >

void dash::TeamSpec< MaxDimensions, IndexType >::resize ( const std::array< SizeType_, MaxDimensions > &  extents )

inline

Change the extent of the cartesian space in every dimension.

Definition at line 426 of file TeamSpec.h.

  {
    _is_linear = false;
    parent_t::resize(extents);
    update_rank();
  }

resize_dim()

template<dim_t MaxDimensions, typename IndexType = dash::default_index_t>

void dash::TeamSpec< MaxDimensions, IndexType >::resize_dim ( dim_t  dim, SizeType  extent  )

inline

Change the extent of the cartesian space in the given dimension.

Definition at line 436 of file TeamSpec.h.

  {
    this->_extents[dim] = extent;
    resize(this->_extents);
  }

size()

constexpr SizeType dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::size ( ) const

inlinenoexceptinherited

The number of discrete elements within the space spanned by the coordinate.

Returns

The number of discrete elements in the coordinate's space

Definition at line 395 of file Cartesian.h.

Referenced by dash::TeamSpec< NumDimensions, IndexType >::balance_extents(), dash::TeamSpec< NumDimensions, IndexType >::includes_index(), dash::make_team_spec(), and dash::TeamSpec< NumDimensions, IndexType >::TeamSpec().

                                           {
    return _size;
  }

x()

constexpr std::enable_if< (U > 0), SizeType >::type dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::x ( SizeType  offs ) const

inlineinherited

Accessor for dimension 1 (x), enabled for dimensionality > 0.

Definition at line 591 of file Cartesian.h.

                         {
    return coords(offs)[0];
  }

y()

constexpr std::enable_if< (U > 1), SizeType >::type dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::y ( SizeType  offs ) const

inlineinherited

Accessor for dimension 2 (y), enabled for dimensionality > 1.

Definition at line 600 of file Cartesian.h.

                         {
    return coords(offs)[1];
  }

z()

constexpr std::enable_if< (U > 2), SizeType >::type dash::CartesianIndexSpace< NumDimensions, Arrangement, IndexType >::z ( SizeType  offs ) const

inlineinherited

Accessor for dimension 3 (z), enabled for dimensionality > 2.

Definition at line 609 of file Cartesian.h.

                         {
    return coords(offs)[2];
  }

---

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

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