ArrayView.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2021, Lawrence Livermore National Security, LLC and LvArray contributors.
 * All rights reserved.
 * See the LICENSE file for details.
 * SPDX-License-Identifier: (BSD-3-Clause)
 */

#pragma once

// Source includes
#include "ArraySlice.hpp"
#include "Macros.hpp"
#include "indexing.hpp"
#include "limits.hpp"
#include "sliceHelpers.hpp"
#include "bufferManipulation.hpp"
#include "umpireInterface.hpp"

// System includes
#if defined(LVARRAY_USE_TOTALVIEW_OUTPUT) && !defined(__CUDA_ARCH__)
#include "totalview/tv_helpers.hpp"
#include "totalview/tv_data_display.h"
#endif

namespace LvArray
{

template< typename T,
          int NDIM_TPARAM,
          int USD_TPARAM,
          typename INDEX_TYPE,
          template< typename > class BUFFER_TYPE >
class ArrayView
{
public:

  static_assert( NDIM_TPARAM > 0, "Number of dimensions must be greater than zero." );
  static_assert( USD_TPARAM >= 0, "USD must be positive." );
  static_assert( USD_TPARAM < NDIM_TPARAM, "USD must be less than NDIM." );

  using ValueType = T;

  static constexpr int NDIM = NDIM_TPARAM;

  static constexpr int USD = USD_TPARAM;

  using IndexType = INDEX_TYPE;

  using ViewTypeConst = ArrayView< std::remove_const_t< T > const, NDIM, USD, INDEX_TYPE, BUFFER_TYPE >;


  using NestedViewType = ArrayView< std::remove_reference_t< typeManipulation::NestedViewType< T > >,
                                    NDIM, USD, INDEX_TYPE, BUFFER_TYPE >;

  using NestedViewTypeConst = ArrayView< std::remove_reference_t< typeManipulation::NestedViewTypeConst< T > >,
                                         NDIM, USD, INDEX_TYPE, BUFFER_TYPE >;

  using SliceType = ArraySlice< T, NDIM, USD, INDEX_TYPE > const;

  using SliceTypeConst = ArraySlice< T const, NDIM, USD, INDEX_TYPE > const;

  using value_type = T;

  using size_type = INDEX_TYPE;


  ArrayView() = default;

  DISABLE_HD_WARNING
  inline LVARRAY_HOST_DEVICE constexpr
  ArrayView( ArrayView const & source ) noexcept:
    m_dims{ source.m_dims },
    m_strides{ source.m_strides },
    m_dataBuffer{ source.m_dataBuffer, source.size() },
    m_singleParameterResizeIndex( source.m_singleParameterResizeIndex )
  {}

  template< typename U, typename=std::enable_if_t< !std::is_same< T, U >::value > >
  inline LVARRAY_HOST_DEVICE constexpr
  explicit ArrayView( ArrayView< U, NDIM, USD, INDEX_TYPE, BUFFER_TYPE > const & source ):
    m_dims{ source.dimsArray() },
    m_strides{ source.stridesArray() },
    m_dataBuffer{ source.dataBuffer() },
    m_singleParameterResizeIndex( source.getSingleParameterResizeIndex() )
  {
    m_dims[ USD ] = typeManipulation::convertSize< T, U >( m_dims[ USD ] );

    for( int i = 0; i < NDIM; ++i )
    {
      if( i != USD )
      {
        m_strides[ i ] = typeManipulation::convertSize< T, U >( m_strides[ i ] );
      }
    }
  }

  ArrayView( ArrayView && source ) = default;

  inline LVARRAY_HOST_DEVICE constexpr explicit
  ArrayView( typeManipulation::CArray< INDEX_TYPE, NDIM > const & dims,
             typeManipulation::CArray< INDEX_TYPE, NDIM > const & strides,
             int const singleParameterResizeIndex,
             BUFFER_TYPE< T > const & buffer ):
    m_dims( dims ),
    m_strides( strides ),
    m_dataBuffer( buffer ),
    m_singleParameterResizeIndex( singleParameterResizeIndex )
  {}

  ~ArrayView() = default;

  inline LVARRAY_HOST_DEVICE LVARRAY_INTEL_CONSTEXPR
  ArrayView & operator=( ArrayView && rhs )
  {
    m_dataBuffer = std::move( rhs.m_dataBuffer );
    m_singleParameterResizeIndex = rhs.m_singleParameterResizeIndex;
    for( int i = 0; i < NDIM; ++i )
    {
      m_dims[ i ] = rhs.m_dims[ i ];
      m_strides[ i ] = rhs.m_strides[ i ];
    }

    return *this;
  }

  inline LVARRAY_INTEL_CONSTEXPR
  ArrayView & operator=( ArrayView const & rhs ) noexcept
  {
    m_dataBuffer = rhs.m_dataBuffer;
    m_singleParameterResizeIndex = rhs.m_singleParameterResizeIndex;
    for( int i = 0; i < NDIM; ++i )
    {
      m_dims[ i ] = rhs.m_dims[ i ];
      m_strides[ i ] = rhs.m_strides[ i ];
    }

    return *this;
  }



  inline LVARRAY_HOST_DEVICE constexpr
  ArrayView toView() const &
  { return ArrayView( m_dims, m_strides, m_singleParameterResizeIndex, m_dataBuffer ); }

  inline LVARRAY_HOST_DEVICE constexpr
  ViewTypeConst toViewConst() const &
  {
    return ViewTypeConst( m_dims,
                          m_strides,
                          m_singleParameterResizeIndex,
                          m_dataBuffer );
  }

  inline LVARRAY_HOST_DEVICE constexpr
  NestedViewType toNestedView() const &
  { return reinterpret_cast< NestedViewType const & >( *this ); }

  inline LVARRAY_HOST_DEVICE constexpr
  NestedViewTypeConst toNestedViewConst() const &
  { return reinterpret_cast< NestedViewTypeConst const & >( *this ); }

  inline LVARRAY_HOST_DEVICE constexpr
  ArraySlice< T, NDIM, USD, INDEX_TYPE >
  toSlice() const & noexcept
  { return ArraySlice< T, NDIM, USD, INDEX_TYPE >( data(), m_dims.data, m_strides.data ); }

  inline LVARRAY_HOST_DEVICE constexpr
  ArraySlice< T, NDIM, USD, INDEX_TYPE >
  toSlice() const && noexcept = delete;

  inline LVARRAY_HOST_DEVICE constexpr
  ArraySlice< T const, NDIM, USD, INDEX_TYPE >
  toSliceConst() const & noexcept
  { return ArraySlice< T const, NDIM, USD, INDEX_TYPE >( data(), m_dims.data, m_strides.data ); }

  inline LVARRAY_HOST_DEVICE constexpr
  ArraySlice< T const, NDIM, USD, INDEX_TYPE >
  toSliceConst() const && noexcept = delete;

  template< typename _T=T >
  inline LVARRAY_HOST_DEVICE constexpr
  operator std::enable_if_t< !std::is_const< _T >::value,
                             ArrayView< T const, NDIM, USD, INDEX_TYPE, BUFFER_TYPE > >() const noexcept
  { return toViewConst(); }

  inline LVARRAY_HOST_DEVICE constexpr
  operator ArraySlice< T, NDIM, USD, INDEX_TYPE >() const & noexcept
  { return toSlice(); }

  inline LVARRAY_HOST_DEVICE constexpr
  operator ArraySlice< T, NDIM, USD, INDEX_TYPE >() const && noexcept = delete;

  template< typename _T=T >
  inline LVARRAY_HOST_DEVICE constexpr
  operator std::enable_if_t< !std::is_const< _T >::value,
                             ArraySlice< T const, NDIM, USD, INDEX_TYPE > const >() const & noexcept
  { return toSliceConst(); }

  template< typename _T=T >
  inline LVARRAY_HOST_DEVICE constexpr
  operator std::enable_if_t< !std::is_const< _T >::value,
                             ArraySlice< T const, NDIM, USD, INDEX_TYPE > const >() const && noexcept = delete;



  LVARRAY_HOST_DEVICE inline constexpr
  INDEX_TYPE size() const noexcept
  {
  #if defined( __ibmxl__ )
    // Note: This used to be done with a recursive template but XL-release would produce incorrect results.
    // Specifically in exampleArray it would return an "old" size even after being updated, strange.
    INDEX_TYPE val = m_dims[ 0 ];
    for( int i = 1; i < NDIM; ++i )
    { val *= m_dims[ i ]; }

    return val;
  #else
    return indexing::multiplyAll< NDIM >( m_dims.data );
  #endif
  }

  LVARRAY_HOST_DEVICE inline CONSTEXPR_WITHOUT_BOUNDS_CHECK
  INDEX_TYPE size( int const dim ) const noexcept
  {
#ifdef LVARRAY_BOUNDS_CHECK
    LVARRAY_ASSERT_GE( dim, 0 );
    LVARRAY_ASSERT_GT( NDIM, dim );
#endif
    return m_dims[ dim ];
  }

  LVARRAY_HOST_DEVICE inline constexpr
  bool empty() const
  { return size() == 0; }

  LVARRAY_HOST_DEVICE constexpr
  INDEX_TYPE capacity() const
  { return LvArray::integerConversion< INDEX_TYPE >( m_dataBuffer.capacity() ); }

  LVARRAY_HOST_DEVICE inline constexpr
  int getSingleParameterResizeIndex() const
  { return m_singleParameterResizeIndex; }

  template< typename ... INDICES >
  LVARRAY_HOST_DEVICE inline CONSTEXPR_WITHOUT_BOUNDS_CHECK
  INDEX_TYPE linearIndex( INDICES const ... indices ) const
  {
    static_assert( sizeof ... (INDICES) == NDIM, "number of indices does not match NDIM" );
#ifdef LVARRAY_BOUNDS_CHECK
    indexing::checkIndices( m_dims.data, indices ... );
#endif
    return indexing::getLinearIndex< USD >( m_strides.data, indices ... );
  }

  LVARRAY_HOST_DEVICE inline constexpr
  INDEX_TYPE const * dims() const noexcept
  { return m_dims.data; }

  LVARRAY_HOST_DEVICE inline constexpr
  typeManipulation::CArray< INDEX_TYPE, NDIM > const & dimsArray() const
  { return m_dims; }

  LVARRAY_HOST_DEVICE inline constexpr
  INDEX_TYPE const * strides() const noexcept
  { return m_strides.data; }

  LVARRAY_HOST_DEVICE inline constexpr
  typeManipulation::CArray< INDEX_TYPE, NDIM > const & stridesArray() const
  { return m_strides; }

  LVARRAY_HOST_DEVICE inline constexpr
  BUFFER_TYPE< T > const & dataBuffer() const
  { return m_dataBuffer; }



  template< int _NDIM=NDIM >
  LVARRAY_HOST_DEVICE inline CONSTEXPR_WITHOUT_BOUNDS_CHECK
  std::enable_if_t< (_NDIM > 1), ArraySlice< T, NDIM - 1, USD - 1, INDEX_TYPE > >
  operator[]( INDEX_TYPE const index ) const & noexcept
  {
    ARRAY_SLICE_CHECK_BOUNDS( index );
    return ArraySlice< T, NDIM-1, USD-1, INDEX_TYPE >( data() + indexing::ConditionalMultiply< USD == 0 >::multiply( index, m_strides[ 0 ] ),
                                                       m_dims.data + 1,
                                                       m_strides.data + 1 );
  }

  template< int _NDIM=NDIM >
  LVARRAY_HOST_DEVICE inline CONSTEXPR_WITHOUT_BOUNDS_CHECK
  std::enable_if_t< (_NDIM > 1), ArraySlice< T, NDIM - 1, USD - 1, INDEX_TYPE > >
  operator[]( INDEX_TYPE const index ) const && noexcept = delete;

  template< int _NDIM=NDIM >
  LVARRAY_HOST_DEVICE inline CONSTEXPR_WITHOUT_BOUNDS_CHECK
  std::enable_if_t< _NDIM == 1, T & >
  operator[]( INDEX_TYPE const index ) const & noexcept
  {
    ARRAY_SLICE_CHECK_BOUNDS( index );
    return data()[ indexing::ConditionalMultiply< USD == 0 >::multiply( index, m_strides[ 0 ] ) ];
  }

  template< typename ... INDICES >
  LVARRAY_HOST_DEVICE inline constexpr
  T & operator()( INDICES... indices ) const
  {
    static_assert( sizeof ... (INDICES) == NDIM, "number of indices does not match NDIM" );
    return data()[ linearIndex( indices ... ) ];
  }

  LVARRAY_HOST_DEVICE inline constexpr
  T * data() const
  { return m_dataBuffer.data(); }

  LVARRAY_HOST_DEVICE inline constexpr
  T * begin() const
  { return data(); }

  LVARRAY_HOST_DEVICE inline constexpr
  T * end() const
  { return data() + size(); }

  T & front() const
  { return data()[ 0 ]; }

  T & back() const
  { return data()[size() - 1]; }



  DISABLE_HD_WARNING
  template< typename POLICY >
  void setValues( T const & value ) const
  {
    auto const view = toView();
    RAJA::forall< POLICY >( RAJA::TypedRangeSegment< INDEX_TYPE >( 0, size() ),
                            [value, view] LVARRAY_HOST_DEVICE ( INDEX_TYPE const i )
      {
        view.data()[ i ] = value;
      } );
  }

  inline void zero() const
  {
  #if !defined( LVARRAY_USE_UMPIRE )
    LVARRAY_ERROR_IF_NE_MSG( getPreviousSpace(), MemorySpace::host, "Without Umpire only host memory is supported." );
  #endif

    if( size() > 0 )
    {
      move( getPreviousSpace(), true );
      umpireInterface::memset( data(), 0, size() * sizeof( T ) );
    }
  }

  template< typename POLICY >
  void setValues( ArrayView< T const, NDIM, USD, INDEX_TYPE, BUFFER_TYPE > const & rhs ) const
  {
    for( int dim = 0; dim < NDIM; ++dim )
    {
      LVARRAY_ERROR_IF_NE( size( dim ), rhs.size( dim ) );
      LVARRAY_ERROR_IF_NE_MSG( strides()[ dim ], rhs.strides()[ dim ],
                               "This method only works with Arrays with the same data layout." );
    }

    auto const view = toView();
    RAJA::forall< POLICY >( RAJA::TypedRangeSegment< INDEX_TYPE >( 0, size() ), [view, rhs] LVARRAY_HOST_DEVICE ( INDEX_TYPE const i )
      {
        view.data()[ i ] = rhs.data()[ i ];
      } );
  }



  MemorySpace getPreviousSpace() const
  { return m_dataBuffer.getPreviousSpace(); }

  void registerTouch( MemorySpace const space ) const
  { m_dataBuffer.registerTouch( space ); }

  void move( MemorySpace const space, bool const touch=true ) const
  { m_dataBuffer.moveNested( space, size(), touch ); }


#if defined(LVARRAY_USE_TOTALVIEW_OUTPUT) && !defined(__CUDA_ARCH__)

  static int TV_ttf_display_type( ArrayView const * av )
  {
    if( av!=nullptr )
    {
      int constexpr ndim = NDIM;
      //std::cout<<"Totalview using ("<<totalview::format<T,INDEX_TYPE>(NDIM, av->m_dims )<<") for display of
      // m_data;"<<std::endl;
      // TV_ttf_add_row( "tv(m_data)", totalview::format< T, INDEX_TYPE >( NDIM, av->m_dims ).c_str(), (av->m_data) );
      // TV_ttf_add_row( "m_data", totalview::format< T, INDEX_TYPE >( 0, av->m_dims ).c_str(), (av->m_data) );
      TV_ttf_add_row( "m_dims", totalview::format< INDEX_TYPE, int >( 1, &ndim ).c_str(), (av->m_dims) );
      TV_ttf_add_row( "m_strides", totalview::format< INDEX_TYPE, int >( 1, &ndim ).c_str(), (av->m_strides) );
      TV_ttf_add_row( "m_dataBuffer", LvArray::system::demangle< BUFFER_TYPE< T > >().c_str(), &(av->m_dataBuffer) );
      TV_ttf_add_row( "m_singleParameterResizeIndex", "int", &(av->m_singleParameterResizeIndex) );
    }
    return 0;
  }
#endif

protected:

  DISABLE_HD_WARNING
  LVARRAY_HOST_DEVICE inline explicit CONSTEXPR_WITHOUT_BOUNDS_CHECK
  ArrayView( bool ) noexcept:
    m_dims{ 0 },
    m_strides{ 0 },
    m_dataBuffer( true )
  {
#if defined(LVARRAY_USE_TOTALVIEW_OUTPUT) && !defined(__CUDA_ARCH__) && defined(LVARRAY_BOUNDS_CHECK)
    ArrayView::TV_ttf_display_type( nullptr );
#endif
  }

  DISABLE_HD_WARNING
  inline LVARRAY_HOST_DEVICE constexpr
  ArrayView( BUFFER_TYPE< T > && buffer ) noexcept:
    m_dims{ 0 },
    m_strides{ 0 },
    m_dataBuffer{ std::move( buffer ) },
    m_singleParameterResizeIndex{ 0 }
  {}

  typeManipulation::CArray< INDEX_TYPE, NDIM > m_dims = { 0 };

  typeManipulation::CArray< INDEX_TYPE, NDIM > m_strides = { 0 };

  BUFFER_TYPE< T > m_dataBuffer;

  int m_singleParameterResizeIndex = 0;
};

template< class >
constexpr bool isArrayView = false;

template< typename T,
          int NDIM,
          int USD,
          typename INDEX_TYPE,
          template< typename > class BUFFER_TYPE >
constexpr bool isArrayView< ArrayView< T, NDIM, USD, INDEX_TYPE, BUFFER_TYPE > > = true;

} // namespace LvArray