ArraySlice.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

#if !defined( NDEBUG ) && !defined( __APPLE__ ) && !defined( __ibmxl__ )

#define DEFINE_GDB_PY_SCRIPT( script_name ) \
  asm (".pushsection \".debug_gdb_scripts\", \"MS\",@progbits,1\n \
                .byte 1 /* Python */\n \
                .asciz \"" script_name "\"\n \
                .popsection \n" );
#else

#define DEFINE_GDB_PY_SCRIPT( script_name )
#endif

DEFINE_GDB_PY_SCRIPT( "scripts/gdb-printers.py" )

// Source includes
#include "LvArrayConfig.hpp"
#include "indexing.hpp"
#include "Macros.hpp"

// System includes
#ifndef NDEBUG
  #include "totalview/tv_data_display.h"
  #include "totalview/tv_helpers.hpp"
#endif

#ifdef LVARRAY_BOUNDS_CHECK

#define ARRAY_SLICE_CHECK_BOUNDS( index ) \
  LVARRAY_ERROR_IF( index < 0 || index >= m_dims[ 0 ], \
                    "Array Bounds Check Failed: index=" << index << " m_dims[0]=" << m_dims[0] )

#else // LVARRAY_BOUNDS_CHECK

#define ARRAY_SLICE_CHECK_BOUNDS( index )

#endif // LVARRAY_BOUNDS_CHECK


namespace LvArray
{

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

  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;


  ArraySlice() = delete;

  LVARRAY_HOST_DEVICE inline explicit CONSTEXPR_WITHOUT_BOUNDS_CHECK
  ArraySlice( T * const LVARRAY_RESTRICT inputData,
              INDEX_TYPE const * const LVARRAY_RESTRICT inputDimensions,
              INDEX_TYPE const * const LVARRAY_RESTRICT inputStrides ) noexcept:
    m_data( inputData ),
    m_dims( inputDimensions ),
    m_strides( inputStrides )
  {
#if defined(LVARRAY_USE_TOTALVIEW_OUTPUT) && !defined(LVARRAY_DEVICE_COMPILE) && defined(LVARRAY_BOUNDS_CHECK)
    ArraySlice::TV_ttf_display_type( nullptr );
#endif
  }



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

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



  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 );
  #endif
  }

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

  LVARRAY_HOST_DEVICE inline CONSTEXPR_WITHOUT_BOUNDS_CHECK
  INDEX_TYPE stride( int const dim ) const noexcept
  {
#ifdef LVARRAY_BOUNDS_CHECK
    LVARRAY_ERROR_IF_GE( dim, NDIM );
#endif
    return m_strides[ dim ];
  }

  LVARRAY_HOST_DEVICE inline constexpr
  bool isContiguous() const
  {
    if( USD < 0 ) return false;
    if( NDIM == 1 && USD == 0 ) return true;

    bool rval = true;
    for( int i = 0; i < NDIM; ++i )
    {
      if( i == USD ) continue;
      INDEX_TYPE prod = 1;
      for( int j = 0; j < NDIM; ++j )
      {
        if( j != i ) prod *= m_dims[j];
      }
      rval &= (m_strides[i] <= prod);
    }
    return rval;
  }

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



  template< int NDIM_=NDIM, int USD_=USD >
  LVARRAY_HOST_DEVICE constexpr inline
  operator std::enable_if_t< NDIM_ == 1 && USD_ == 0, T * const LVARRAY_RESTRICT >
    () const noexcept
  { return m_data; }

  template< int U=NDIM >
  LVARRAY_HOST_DEVICE inline CONSTEXPR_WITHOUT_BOUNDS_CHECK
  std::enable_if_t< (U > 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 >( m_data + indexing::ConditionalMultiply< USD == 0 >::multiply( index, m_strides[ 0 ] ),
                                                       m_dims + 1,
                                                       m_strides + 1 );
  }

  template< int U=NDIM >
  LVARRAY_HOST_DEVICE inline CONSTEXPR_WITHOUT_BOUNDS_CHECK
  std::enable_if_t< U == 1, T & >
  operator[]( INDEX_TYPE const index ) const noexcept
  {
    ARRAY_SLICE_CHECK_BOUNDS( index );
    return m_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 m_data[ linearIndex( indices ... ) ];
  }

  template< int USD_ = USD >
  LVARRAY_HOST_DEVICE inline
  T * dataIfContiguous() const
  {
    // Note: need both compile-time and runtime checks as USD >= 0 does not guarantee contiguous data.
    static_assert( USD_ >= 0, "Direct data access not supported for non-contiguous slices" );
    LVARRAY_ERROR_IF( !isContiguous(), "Direct data access not supported for non-contiguous slices" );
    return m_data;
  }

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

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


#if defined(LVARRAY_USE_TOTALVIEW_OUTPUT) && !defined(LVARRAY_DEVICE_COMPILE) && defined(LVARRAY_BOUNDS_CHECK)

  static int TV_ttf_display_type( ArraySlice 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 >( 1, 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) );
    }
    return 0;
  }
#endif

protected:
  T * const LVARRAY_RESTRICT m_data;

  INDEX_TYPE const * const LVARRAY_RESTRICT m_dims;

  INDEX_TYPE const * const LVARRAY_RESTRICT m_strides;

};

} // namespace LvArray