Matrix.h

#ifndef DASH__MATRIX_H_INCLUDED
#define DASH__MATRIX_H_INCLUDED

#include <dash/dart/if/dart.h>

#include <dash/Team.h>
#include <dash/Pattern.h>
#include <dash/GlobRef.h>
#include <dash/HView.h>
#include <dash/Meta.h>

#include <dash/iterator/GlobIter.h>

#include <dash/matrix/MatrixRefView.h>
#include <dash/matrix/MatrixRef.h>
#include <dash/matrix/LocalMatrixRef.h>

#include <dash/memory/MemorySpace.h>
#include <dash/memory/UniquePtr.h>

#include <type_traits>


namespace dash {

template <
  typename T,
  dim_t NumDimensions,
  typename IndexT,
  class PatternT,
  typename LocalMemSpaceT>
class Matrix;
template <
  typename T,
  dim_t NumDimensions,
  dim_t CUR,
  class PatternT,
  typename LocalMemSpaceT>
class MatrixRef;
template <
  typename T,
  dim_t NumDimensions,
  dim_t CUR,
  class Pattern,
  typename LocalMemSpaceT>
class LocalMatrixRef;

template<
  typename ElementT,
  dim_t    NumDimensions,
  typename IndexT         = dash::default_index_t,
  class    PatternT       = TilePattern<NumDimensions, ROW_MAJOR, IndexT>,
  typename LocalMemSpaceT = HostSpace>
class Matrix
{
  static_assert(
    dash::is_container_compatible<ElementT>::value,
    "Type not supported for DASH containers");

  static_assert(std::is_same<IndexT, typename PatternT::index_type>::value,
    "Index type IndexT must be the same for Matrix and specified pattern");

private:
  typedef Matrix<ElementT, NumDimensions, IndexT, PatternT, LocalMemSpaceT>
    self_t;
  typedef typename std::make_unsigned<IndexT>::type
    SizeType;
  typedef MatrixRefView<ElementT, NumDimensions, PatternT, LocalMemSpaceT>
    MatrixRefView_t;
  typedef LocalMatrixRef<ElementT, NumDimensions, NumDimensions, PatternT, LocalMemSpaceT>
    LocalRef_t;
  typedef LocalMatrixRef<
            const ElementT, NumDimensions, NumDimensions, PatternT, LocalMemSpaceT>
    LocalRef_const_t;
  typedef PatternT
    Pattern_t;

public:
  typedef GlobStaticMem<LocalMemSpaceT>
    GlobMem_t;

  template<
    typename T_,
    dim_t NumDimensions1,
    dim_t NumDimensions2,
    class PatternT_,
    typename MSpaceC>
  friend class MatrixRef;
  template<
    typename T_,
    dim_t NumDimensions1,
    dim_t NumDimensions2,
    class PatternT_,
    typename MSpaceC>
  friend class LocalMatrixRef;


public:
  typedef ElementT                                              value_type;
  typedef typename PatternT::size_type                           size_type;
  typedef typename PatternT::index_type                    difference_type;
  typedef typename PatternT::index_type                         index_type;

  typedef GlobIter<      value_type, Pattern_t, GlobMem_t>        iterator;
  typedef GlobIter<const value_type, Pattern_t, GlobMem_t>  const_iterator;

  typedef std::reverse_iterator<iterator>                 reverse_iterator;
  typedef std::reverse_iterator<const_iterator>     const_reverse_iterator;

  typedef          GlobRef<value_type>                           reference;
  typedef typename GlobRef<value_type>::const_type         const_reference;

  // TODO rko: use iterator traits
  typedef typename iterator::pointer   pointer;
  typedef typename pointer::const_type const_pointer;

  typedef       ElementT *                                   local_pointer;
  typedef const ElementT *                             const_local_pointer;

  typedef DistributionSpec<NumDimensions>                distribution_spec;
  typedef SizeSpec<NumDimensions, typename PatternT::size_type>
    size_spec;
  typedef TeamSpec<NumDimensions, typename PatternT::index_type>
    team_spec;
  typedef std::array<typename PatternT::size_type, NumDimensions>
    extents_type;
  typedef std::array<typename PatternT::index_type, NumDimensions>
    offsets_type;


// Public types as required by dash container concept
public:
  typedef LocalMatrixRef<
            ElementT, NumDimensions, NumDimensions, PatternT, LocalMemSpaceT>
    local_type;

  typedef LocalMatrixRef<
            const ElementT, NumDimensions, NumDimensions, PatternT, LocalMemSpaceT>
    const_local_type;

  typedef PatternT                                            pattern_type;

  template <dim_t NumViewDim>
    using view_type =
          MatrixRef<ElementT, NumDimensions, NumViewDim, PatternT, LocalMemSpaceT>;

  template <dim_t NumViewDim>
    using const_view_type =
          MatrixRef<const ElementT, NumDimensions, NumViewDim, PatternT, LocalMemSpaceT>;

// public types exposed in Matrix interface
public:

public:
  local_type local;

public:

  typedef std::integral_constant<dim_t, NumDimensions>                rank;

  static constexpr dim_t ndim() {
    return NumDimensions;
  }
private:
  using allocator_type = dash::GlobalAllocator<std::byte, GlobMem_t>;

  using unique_gptr_t = decltype(dash::allocate_unique<value_type>(
      allocator_type{}, std::size_t{}));

private:
  dash::Team *_team = nullptr;
  size_type _size;
  size_type _lsize;
  size_type _lcapacity;
  iterator _begin;
  Pattern_t _pattern;
  GlobMem_t _glob_mem{};
  allocator_type _allocator;
  unique_gptr_t _data{};
  ElementT *_lbegin{};
  ElementT *_lend{};
  view_type<NumDimensions> _ref;

public:
  explicit
  Matrix(
    Team & team = dash::Team::Null());

  explicit
  Matrix(
    const size_spec         & ss,
    const distribution_spec & ds  = distribution_spec(),
    Team                    & t   = dash::Team::All(),
    const team_spec         & ts  = team_spec());

  explicit
  Matrix(
    const PatternT & pat);

  template<typename... Args>
  Matrix(SizeType arg, Args&&... args)
  : Matrix(PatternT(arg, std::forward<Args>(args)...))
  { }

  Matrix(const self_t &) = delete;

  Matrix(self_t && other);

  ~Matrix();

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

  self_t & operator=(self_t && other);

  view_type<NumDimensions> block(
    const std::array<index_type, NumDimensions> & block_gcoords);

  view_type<NumDimensions> block(
    index_type block_gindex);

  bool allocate(
    const size_spec         & sizespec,
    const distribution_spec & distribution,
    const team_spec         & teamspec,
    dash::Team              & team = dash::Team::All()
  );

  bool allocate(
    const PatternT & pattern
  );


  template<typename... Args>
  bool
  allocate(SizeType arg, Args... args)
  {
    return allocate(PatternT(arg, args... ));
  }

  void deallocate();

  constexpr Team            & team()                const noexcept;

  constexpr size_type         size()                const noexcept;
  constexpr size_type         local_size()          const noexcept;
  constexpr size_type         local_capacity()      const noexcept;
  constexpr size_type         extent(dim_t dim)     const noexcept;
  constexpr extents_type      extents()             const noexcept;
  constexpr index_type        offset(dim_t dim)     const noexcept;
  constexpr offsets_type      offsets()             const noexcept;
  constexpr bool              empty()               const noexcept;

  inline void                 barrier() const;

  inline void                 flush();

  inline void                 flush(dash::team_unit_t target);

  inline void                 flush_local();

  inline void                 flush_local(dash::team_unit_t target);

  constexpr const Pattern_t & pattern() const;

                  iterator    begin()         noexcept;

  constexpr const_iterator    begin()   const noexcept;

                  iterator    end()           noexcept;

  constexpr const_iterator    end( )    const noexcept;

                  ElementT *  lbegin()        noexcept;

  constexpr const ElementT *  lbegin()  const noexcept;

                  ElementT *  lend()          noexcept;

  constexpr const ElementT *  lend()    const noexcept;

  template<dim_t __NumViewDim = NumDimensions-1>
  typename std::enable_if<
             (__NumViewDim != 0),
             const_view_type<__NumViewDim>
           >::type
  constexpr operator[](
    size_type n       
  ) const;

  template<dim_t __NumViewDim = NumDimensions-1>
  typename std::enable_if<
             (__NumViewDim == 0),
             const_reference
           >::type
  constexpr operator[](
    size_type n       
  ) const;

  template<dim_t __NumViewDim = NumDimensions-1>
  typename std::enable_if<(__NumViewDim != 0), view_type<__NumViewDim>>::type
  operator[](
    size_type n       
  );

  template<dim_t __NumViewDim = NumDimensions-1>
  typename std::enable_if<(__NumViewDim == 0), reference>::type
  operator[](
    size_type n       
  );

  template<dim_t SubDimension>
  const_view_type<NumDimensions> sub(
    size_type n,      
    size_type range   
  ) const;

  template<dim_t SubDimension>
  view_type<NumDimensions> sub(
    size_type n,      
    size_type range   
  );

  template<dim_t SubDimension>
  const_view_type<NumDimensions-1> sub(
    size_type n       
  ) const;

  template<dim_t SubDimension>
  view_type<NumDimensions-1> sub(
    size_type n       
  );

  local_type sub_local() noexcept;

  const_view_type<NumDimensions-1> col(
    size_type n       
  ) const;

  view_type<NumDimensions-1> col(
    size_type n       
  );

  const_view_type<NumDimensions-1> row(
    size_type n       
  ) const;

  view_type<NumDimensions-1> row(
    size_type n       
  );

  view_type<NumDimensions> cols(
    size_type offset, 
    size_type range   
  );

  view_type<NumDimensions> rows(
    size_type n,      
    size_type range   
  );

  template<typename ... Args>
  const_reference at(
    Args... args      
  ) const;

  template<typename ... Args>
  reference at(
    Args... args      
  );

  template<typename... Args>
  const_reference operator()(
    Args... args      
  ) const;

  template<typename... Args>
  reference operator()(
    Args... args      
  );

  constexpr bool is_local(
    size_type g_pos   
  ) const;

  template<dim_t Dimension>
  constexpr bool is_local(
    size_type g_pos   
  ) const;

  template <int level>
  dash::HView<self_t, level> hview();

  operator
    MatrixRef<ElementT, NumDimensions, NumDimensions, PatternT, LocalMemSpaceT> ();

private:
  void destruct_at_end(value_type *new_last);
};

template <
  typename T,
  dim_t    NumDimensions,
  typename IndexT   = dash::default_index_t,
  class    PatternT = Pattern<NumDimensions, ROW_MAJOR, IndexT>,
  typename LocalMemSpaceT = HostSpace>
using NArray = dash::Matrix<T, NumDimensions, IndexT, PatternT, LocalMemSpaceT>;

}  // namespace dash

#include <dash/matrix/internal/Matrix-inl.h>

#endif  // DASH__MATRIX_H_INCLUDED