Dimensional.h

#ifndef DASH__DIMENSIONAL_H_
#define DASH__DIMENSIONAL_H_

#include <dash/Types.h>
#include <dash/Distribution.h>
#include <dash/Team.h>
#include <dash/Exception.h>

#include <array>
#include <sstream>
#include <utility>
namespace dash {

template <typename DimensionalType>
constexpr dim_t ndim(const DimensionalType & d) {
  return d.ndim();
}

template <typename DimensionalType>
constexpr dim_t rank(const DimensionalType & d) {
  return d.rank();
}

template <dim_t Dim, typename DimensionalType>
constexpr typename DimensionalType::extent_type
extent(const DimensionalType & d) {
  return d.extent(Dim);
}

template <typename DimensionalType>
constexpr typename DimensionalType::extent_type
extent(dim_t dim, const DimensionalType & d) {
  return d.extent(dim);
}

template <typename ElementType, dim_t NumDimensions>
class Dimensional
{
  template <typename E_, dim_t ND_>
  friend std::ostream & operator<<(
    std::ostream & os,
    const Dimensional<E_, ND_> & dimensional);

private:
  typedef Dimensional<ElementType, NumDimensions> self_t;

protected:
  std::array<ElementType, NumDimensions> _values;

public:
  template <typename ... Values>
  constexpr Dimensional(
    ElementType & value, Values ... values)
  : _values {{ value, (ElementType)values... }} {
    static_assert(
      sizeof...(values) == NumDimensions-1,
      "Invalid number of arguments");
  }

  constexpr Dimensional(std::array<ElementType, NumDimensions> values)
    : _values(std::move(values))
  {
  }

  constexpr Dimensional(const self_t & other) = default;
  self_t & operator=(const self_t & other)    = default;

  constexpr const std::array<ElementType, NumDimensions> & values() const {
    return _values;
  }

  ElementType dim(dim_t dimension) const {
    DASH_ASSERT_LT(
      dimension, NumDimensions,
      "Dimension for Dimensional::extent() must be lower than " <<
      NumDimensions);
    return _values[dimension];
  }

  constexpr ElementType operator[](size_t dimension) const {
    return _values[dimension];
  }

  ElementType & operator[](size_t dimension) {
    return _values[dimension];
  }

  constexpr bool operator==(const self_t & other) const {
    return this == &other || _values == other._values;
  }

  constexpr bool operator!=(const self_t & other) const {
    return !(*this == other);
  }

  constexpr dim_t rank() const {
    return NumDimensions;
  }

  constexpr static dim_t ndim() {
    return NumDimensions;
  }

protected:
  Dimensional() = default;
};

template <dim_t NumDimensions>
class DistributionSpec : public Dimensional<Distribution, NumDimensions>
{
  template<dim_t NumDimensions_>
  friend
  std::ostream & operator<<(
    std::ostream & os,
    const DistributionSpec<NumDimensions_> & distspec);

private:
  typedef Dimensional<Distribution, NumDimensions> base_t;

public:
  DistributionSpec()
  {
    this->_values[0] = BLOCKED;
    for (dim_t i = 1; i < NumDimensions; ++i) {
      this->_values[i] = NONE;
    }
  }

  template <typename... Values>
  DistributionSpec(Distribution value, Values... values)
    : Dimensional<Distribution, NumDimensions>::Dimensional(value, values...)
  {
    for (dim_t i = 1; i < NumDimensions; ++i) {
      if (this->_values[i].type == dash::internal::DIST_TILE) {
        _is_tiled = true;
        break;
      }
    }
  }

  DistributionSpec(const std::array<Distribution, NumDimensions>& values)
    : Dimensional<Distribution, NumDimensions>::Dimensional(values)
  {
    DASH_LOG_TRACE_VAR("DistributionSpec(distribution[])", values);
    for (dim_t i = 1; i < NumDimensions; ++i) {
      if (this->_values[i].type == dash::internal::DIST_TILE) {
        _is_tiled = true;
        break;
      }
    }
  }

  bool is_tiled_in_dimension(
    unsigned int dimension) const {
    return (_is_tiled &&
            this->_values[dimension].type == dash::internal::DIST_TILE);
  }

  bool is_tiled() const {
    return _is_tiled;
  }

private:
  bool _is_tiled{false};
};

template<dim_t NumDimensions>
std::ostream & operator<<(
  std::ostream & os,
  const DistributionSpec<NumDimensions> & distspec)
{
  os << "dash::DistributionSpec<" << NumDimensions << ">(";
  for (dim_t d = 0; d < NumDimensions; d++) {
    if (distspec._values[d].type == dash::internal::DIST_TILE) {
      os << "TILE(" << distspec._values[d].blocksz << ")";
    }
    else if (distspec._values[d].type == dash::internal::DIST_BLOCKCYCLIC) {
      os << "BLOCKCYCLIC(" << distspec._values[d].blocksz << ")";
    }
    else if (distspec._values[d].type == dash::internal::DIST_CYCLIC) {
      os << "CYCLIC";
    }
    else if (distspec._values[d].type == dash::internal::DIST_BLOCKED) {
      os << "BLOCKED";
    }
    else if (distspec._values[d].type == dash::internal::DIST_NONE) {
      os << "NONE";
    }
    if (d < NumDimensions-1) {
      os << ", ";
    }
  }
  os << ")";
  return os;
}

template<typename IndexType = int>
struct ViewPair {
  typedef typename std::make_unsigned<IndexType>::type SizeType;
  IndexType offset;
  SizeType  extent;
};

template<
  dim_t    NumDimensions,
  typename IndexType = dash::default_index_t>
struct ViewRegion {
  // Region origin coordinates.
  std::array<IndexType, NumDimensions> begin;
  // Region end coordinates.
  std::array<IndexType, NumDimensions> end;
};

template<
  typename IndexType = dash::default_index_t>
struct ViewRange {
  // Range begin offset.
  IndexType begin;
  // Range end offset.
  IndexType end;
};

template<typename IndexType>
std::ostream & operator<<(
  std::ostream & os,
  const ViewRange<IndexType> & viewrange) {
  os << "dash::ViewRange<" << typeid(IndexType).name() << ">("
     << "begin:" << viewrange.begin << " "
     << "end:"   << viewrange.end << ")";
  return os;
}

template<typename IndexType>
static bool operator==(
  const ViewPair<IndexType> & lhs,
  const ViewPair<IndexType> & rhs) {
  if (&lhs == &rhs) {
    return true;
  }
  return (
    lhs.offset == rhs.offset &&
    lhs.extent == rhs.extent);
}

template<typename IndexType>
static bool operator!=(
  const ViewPair<IndexType> & lhs,
  const ViewPair<IndexType> & rhs) {
  return !(lhs == rhs);
}

template<typename IndexType>
std::ostream & operator<<(
  std::ostream & os,
  const ViewPair<IndexType> & viewpair) {
  os << "dash::ViewPair<" << typeid(IndexType).name() << ">("
     << "offset:" << viewpair.offset << " "
     << "extent:" << viewpair.extent << ")";
  return os;
}

template<
  dim_t    NumDimensions,
  typename IndexType = dash::default_index_t >
class ViewSpec
{
private:
  typedef ViewSpec<NumDimensions, IndexType>
    self_t;
  typedef typename std::make_unsigned<IndexType>::type
    SizeType;
  typedef ViewPair<IndexType>
    ViewPair_t;

public:
  typedef ViewRegion<NumDimensions, IndexType> region_type;
  typedef ViewRange<IndexType>                 range_type;

  using index_type = IndexType;
  using size_type  = SizeType;

public:
  template<dim_t NDim_, typename IndexType_>
  friend std::ostream& operator<<(
    std::ostream & os,
    const ViewSpec<NDim_, IndexType_> & viewspec);

private:
  SizeType                             _size    = 0;
  SizeType                             _rank    = NumDimensions;
  std::array<SizeType, NumDimensions>  _extents = {{ }};
  std::array<IndexType, NumDimensions> _offsets = {{ }};

public:
  ViewSpec()
  : _size(0),
    _rank(NumDimensions)
  {
    for (dim_t i = 0; i < NumDimensions; i++) {
      _extents[i] = 0;
      _offsets[i] = 0;
    }
  }

  ViewSpec(
    const std::array<SizeType, NumDimensions> & extents)
  : _size(1),
    _rank(NumDimensions),
    _extents(extents)
  {
    for (auto i = 0; i < NumDimensions; ++i) {
      _offsets[i] = 0;
      _size      *= _extents[i];
    }
  }

  ViewSpec(
    const std::array<IndexType, NumDimensions> & offsets,
    const std::array<SizeType, NumDimensions>  & extents)
  : _size(1),
    _rank(NumDimensions),
    _extents(extents),
    _offsets(offsets)
  {
    for (auto i = 0; i < NumDimensions; ++i) {
      _size *= _extents[i];
    }
  }

  constexpr ViewSpec(const self_t & other) = default;

  constexpr ViewSpec(self_t && other)      = default;

  self_t & operator=(const self_t & other) = default;

  self_t & operator=(self_t && other)      = default;

  static constexpr auto ndim() { return NumDimensions; }

  constexpr bool operator==(const self_t & other) const
  {
    return (_extents == other._extents &&
            _offsets == other._offsets &&
            _rank    == other._rank);
  }

  constexpr bool operator!=(const self_t & other) const
  {
    return !(*this == other);
  }

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

  void resize(const std::array<ViewPair_t, NumDimensions> & view)
  {
    _rank = NumDimensions;
    for (dim_t i = 0; i < NumDimensions; i++) {
      _offsets[i] = view[i].offset;
      _extents[i] = view[i].extent;
    }
    update_size();
  }

  template<typename SizeType_>
  void resize(const std::array<SizeType_, NumDimensions> & extents)
  {
    _rank = NumDimensions;
    for (dim_t i = 0; i < NumDimensions; i++) {
      _extents[i] = extents[i];
    }
    update_size();
  }

  void resize_dim(
    dim_t     dimension,
    IndexType offset,
    SizeType  extent)
  {
    _offsets[dimension] = offset;
    _extents[dimension] = extent;
    update_size();
  }

  ViewSpec<NumDimensions-1, IndexType>
  slice(dim_t dimension)
  {
    std::array<SizeType, NumDimensions-1>  slice_extents;
    std::array<IndexType, NumDimensions-1> slice_offsets;
    for (dim_t d = dimension; d < _rank-1; d++) {
      slice_offsets[d] = _offsets[d+1];
      slice_extents[d] = _extents[d+1];
    }
    return ViewSpec<NumDimensions-1, IndexType>(slice_offsets,
                                                slice_extents);
  }

  void set_rank(dim_t dimensions)
  {
    DASH_ASSERT_LT(
      dimensions, NumDimensions+1,
      "Maximum dimension for ViewSpec::set_rank is " << NumDimensions);
    _rank = dimensions;
    update_size();
  }

  constexpr SizeType size() const
  {
    return _size;
  }

  constexpr SizeType size(dim_t dimension) const
  {
    return _extents[dimension];
  }

  constexpr const std::array<SizeType, NumDimensions> & extents() const
  {
    return _extents;
  }

  constexpr SizeType extent(dim_t dim) const {
    return _extents[dim];
  }

  constexpr const std::array<IndexType, NumDimensions> & offsets() const
  {
    return _offsets;
  }

  constexpr range_type range(dim_t dim) const
  {
    return range_type {
             static_cast<IndexType>(_offsets[dim]),
             static_cast<IndexType>(_offsets[dim] + _extents[dim]) };
  }

  constexpr IndexType offset(dim_t dim) const
  {
    return _offsets[dim];
  }

  region_type region() const
  {
    region_type reg;
    reg.begin = _offsets;
    reg.end   = _offsets;
    for (dim_t d = 0; d < NumDimensions; ++d) {
      reg.end[d] += static_cast<IndexType>(_extents[d]);
    }
    return reg;
  }

private:
  void update_size()
  {
    _size = 1;
    for (SizeType d = 0; d < NumDimensions; ++d) {
      _size *= _extents[d];
    }
  }
};

template<typename ElementType, dim_t NumDimensions>
std::ostream & operator<<(
  std::ostream & os,
  const Dimensional<ElementType, NumDimensions> & dimensional)
{
  std::ostringstream ss;
  ss << "dash::Dimensional<"
     << typeid(ElementType).name() << ","
     << NumDimensions << ">(";
  for (auto d = 0; d < NumDimensions; ++d) {
    ss << dimensional._values[d] << ((d < NumDimensions-1) ? "," : "");
  }
  ss << ")";
  return operator<<(os, ss.str());
}

template<dim_t NumDimensions, typename IndexType>
std::ostream& operator<<(
    std::ostream & os,
    const ViewSpec<NumDimensions, IndexType> & viewspec)
{
  std::ostringstream ss;
  ss << "dash::ViewSpec<" << NumDimensions << ">"
     << "(offsets:";
  for (auto d = 0; d < NumDimensions; ++d) {
    if (d > 0) {
      ss << ",";
    }
    ss << viewspec.offsets()[d];
  }
  ss << " extents:";
  for (auto d = 0; d < NumDimensions; ++d) {
    if (d > 0) {
      ss << ",";
    }
    ss << viewspec.extents()[d];
  }
  ss << ")";
  return operator<<(os, ss.str());
}

} // namespace dash

#endif // DASH__DIMENSIONAL_H_