Array.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 "indexing.hpp"
#include "ArrayView.hpp"
#include "bufferManipulation.hpp"
#include "StackBuffer.hpp"

namespace LvArray
{

template< typename T,
          int NDIM,
          typename PERMUTATION,
          typename INDEX_TYPE,
          template< typename > class BUFFER_TYPE >
class Array : public ArrayView< T,
                     NDIM,
  typeManipulation::getStrideOneDimension( PERMUTATION {} ),
                     INDEX_TYPE,
                     BUFFER_TYPE >
{
public:

  // Check that the template arguments are valid.
  static_assert( NDIM >= 0, "The dimension of the Array must be positive." );
  static_assert( typeManipulation::isValidPermutation( PERMUTATION {} ), "The permutation must be valid." );
  static_assert( typeManipulation::getDimension< PERMUTATION > == NDIM,
                 "The dimension of the permutation must match the dimension of the Array." );
  static_assert( std::is_integral< INDEX_TYPE >::value, "INDEX_TYPE must be integral." );

  using Permutation = PERMUTATION;

  using ParentClass = ArrayView< T, NDIM, typeManipulation::getStrideOneDimension( Permutation {} ), INDEX_TYPE, BUFFER_TYPE >;

  using ParentClass::USD;
  using typename ParentClass::NestedViewType;
  using typename ParentClass::NestedViewTypeConst;


  LVARRAY_HOST_DEVICE
  inline Array():
    ParentClass( true )
  {
    this->m_strides = indexing::calculateStrides< PERMUTATION >( this->m_dims );

#if !defined(LVARRAY_DEVICE_COMPILE)
    setName( "" );
#endif
#if defined(LVARRAY_USE_TOTALVIEW_OUTPUT) && !defined(LVARRAY_DEVICE_COMPILE)
    Array::TV_ttf_display_type( nullptr );
#endif
  }

  template< typename ... DIMS,
            typename=std::enable_if_t< sizeof ... ( DIMS ) == NDIM &&
                                       typeManipulation::all_of_t< std::is_integral< DIMS > ... >::value > >
  LVARRAY_HOST_DEVICE
  inline explicit Array( DIMS const ... dims ):
    Array()
  { resize( dims ... ); }

  Array( BUFFER_TYPE< T > && buffer ):
    ParentClass( std::move( buffer ) )
  {
    this->m_strides = indexing::calculateStrides< PERMUTATION >( this->m_dims );

#if !defined(LVARRAY_DEVICE_COMPILE)
    setName( "" );
#endif
#if defined(LVARRAY_USE_TOTALVIEW_OUTPUT) && !defined(LVARRAY_DEVICE_COMPILE)
    Array::TV_ttf_display_type( nullptr );
#endif
  }

  LVARRAY_HOST_DEVICE
  Array( Array const & source ):
    Array()
  { *this = source; }

  LVARRAY_HOST_DEVICE
  Array( Array && source ):
    ParentClass( std::move( source ) )
  {
    for( int i = 0; i < NDIM; ++i )
    {
      source.m_dims[ i ] = 0;
      source.m_strides[ i ] = 0;
    }
  }

  LVARRAY_HOST_DEVICE
  ~Array()
  { bufferManipulation::free( this->m_dataBuffer, this->size() ); }

  LVARRAY_HOST_DEVICE
  Array & operator=( Array const & rhs )
  {
    bufferManipulation::copyInto( this->m_dataBuffer, this->size(), rhs.m_dataBuffer, rhs.size() );

    for( int i = 0; i < NDIM; ++i )
    {
      this->m_dims[ i ] = rhs.m_dims[ i ];
      this->m_strides[ i ] = rhs.m_strides[ i ];
    }

    setSingleParameterResizeIndex( rhs.getSingleParameterResizeIndex() );
    return *this;
  }

  LVARRAY_HOST_DEVICE
  Array & operator=( typename ParentClass::ViewTypeConst const & rhs )
  {
    bufferManipulation::copyInto( this->m_dataBuffer, this->size(), rhs.dataBuffer(), rhs.size() );

    INDEX_TYPE const * const dims = rhs.dims();
    INDEX_TYPE const * const strides = rhs.strides();
    for( int i = 0; i < NDIM; ++i )
    {
      this->m_dims[ i ] = dims[ i ];
      this->m_strides[ i ] = strides[ i ];
    }

    setSingleParameterResizeIndex( rhs.getSingleParameterResizeIndex() );
    return *this;
  }

  LVARRAY_HOST_DEVICE
  Array & operator=( Array && rhs )
  {
    bufferManipulation::free( this->m_dataBuffer, this->size() );

    ParentClass::operator=( std::move( rhs ) );

    for( int i = 0; i < NDIM; ++i )
    {
      rhs.m_dims[ i ] = 0;
      rhs.m_strides[ i ] = 0;
    }

    return *this;
  }



  using ParentClass::toView;

  inline LVARRAY_HOST_DEVICE constexpr
  ArrayView< T, NDIM, USD, INDEX_TYPE, BUFFER_TYPE > toView() const && = delete;

  using ParentClass::toViewConst;

  inline LVARRAY_HOST_DEVICE constexpr
  ArrayView< T const, NDIM, USD, INDEX_TYPE, BUFFER_TYPE > toViewConst() const && = delete;

  using ParentClass::toNestedView;

  inline LVARRAY_HOST_DEVICE constexpr
  NestedViewType toNestedView() const && = delete;

  using ParentClass::toNestedViewConst;

  inline LVARRAY_HOST_DEVICE constexpr
  NestedViewTypeConst toNestedViewConst() const && = delete;

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

  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 = delete;



  template< typename DIMS_TYPE >
  LVARRAY_HOST_DEVICE
  void resize( int const numDims, DIMS_TYPE const * const dims )
  {
    LVARRAY_ERROR_IF_NE( numDims, NDIM );

    INDEX_TYPE const oldSize = this->size();
    for( int i = 0; i < NDIM; ++i )
    {
      this->m_dims[ i ] = LvArray::integerConversion< INDEX_TYPE >( dims[ i ] );
      LVARRAY_ERROR_IF_LT( this->m_dims[ i ], 0 );
    }

    this->m_strides = indexing::calculateStrides< PERMUTATION >( this->m_dims );

    bufferManipulation::resize( this->m_dataBuffer, oldSize, this->size() );
  }

  template< typename ... DIMS >
  LVARRAY_HOST_DEVICE
  std::enable_if_t< sizeof ... ( DIMS ) == NDIM && typeManipulation::all_of_t< std::is_integral< DIMS > ... >::value >
  resize( DIMS const ... newDims )
  {
    static_assert( sizeof ... ( DIMS ) == NDIM, "The number of arguments provided does not equal NDIM!" );
    INDEX_TYPE const oldSize = this->size();

    int curDim = 0;
    typeManipulation::forEachArg( [&]( auto const newDim )
    {
      this->m_dims[ curDim ] = LvArray::integerConversion< INDEX_TYPE >( newDim );
      LVARRAY_ERROR_IF_LT( this->m_dims[ curDim ], 0 );
      ++curDim;
    }, newDims ... );

    this->m_strides = indexing::calculateStrides< PERMUTATION >( this->m_dims );

    bufferManipulation::resize( this->m_dataBuffer, oldSize, this->size() );
  }

  template< typename ... DIMS >
  LVARRAY_HOST_DEVICE
  void resizeWithoutInitializationOrDestruction( DIMS const ... newDims )
  {
    return resizeWithoutInitializationOrDestruction( MemorySpace::host, newDims ... );
  }

  template< typename ... DIMS >
  LVARRAY_HOST_DEVICE
  void resizeWithoutInitializationOrDestruction( MemorySpace const space, DIMS const ... newDims )
  {
    static_assert( sizeof ... ( DIMS ) == NDIM, "The number of arguments provided does not equal NDIM!" );
    static_assert( std::is_trivially_destructible< T >::value,
                   "This function is only safe if T is trivially destructable." );

    INDEX_TYPE const oldSize = this->size();

    int i = 0;
    typeManipulation::forEachArg( [&]( auto const newDim )
    {
      this->m_dims[ i ] = LvArray::integerConversion< INDEX_TYPE >( newDim );
      LVARRAY_ERROR_IF_LT( this->m_dims[ i ], 0 );
      ++i;
    }, newDims ... );

    this->m_strides = indexing::calculateStrides< PERMUTATION >( this->m_dims );

    bufferManipulation::reserve( this->m_dataBuffer, oldSize, space, this->size() );
  }

  template< INDEX_TYPE... INDICES, typename ... DIMS >
  LVARRAY_HOST_DEVICE
  void resizeDimension( DIMS const ... newDims )
  {
    static_assert( sizeof ... (INDICES) <= NDIM, "Too many arguments provided." );
    static_assert( sizeof ... (INDICES) == sizeof ... (DIMS),
                   "The number of indices must match the number of dimensions." );
    static_assert( typeManipulation::all_of< ( 0 <= INDICES ) ... >::value, "INDICES must all be positive." );
    static_assert( typeManipulation::all_of< ( INDICES < NDIM ) ... >::value, "INDICES must all be less than NDIM." );

    INDEX_TYPE const oldSize = this->size();

    typeManipulation::forEachArg( [&]( auto const & pair )
    {
      this->m_dims[ camp::get< 0 >( pair ) ] = LvArray::integerConversion< INDEX_TYPE >( camp::get< 1 >( pair ) );
      LVARRAY_ERROR_IF_LT( this->m_dims[ camp::get< 0 >( pair ) ], 0 );
    }, camp::make_tuple( INDICES, newDims )... );

    this->m_strides = indexing::calculateStrides< PERMUTATION >( this->m_dims );

    bufferManipulation::resize( this->m_dataBuffer, oldSize, this->size() );
  }

  LVARRAY_HOST_DEVICE
  void resize( INDEX_TYPE const newdim )
  { resizeDefaultDimension( newdim ); }

  LVARRAY_HOST_DEVICE
  void resizeDefault( INDEX_TYPE const newdim, T const & defaultValue )
  { resizeDefaultDimension( newdim, defaultValue ); }

  void clear()
  {
    bufferManipulation::resize( this->m_dataBuffer, this->size(), 0 );

    this->m_dims[ this->getSingleParameterResizeIndex() ] = 0;

    this->m_strides = indexing::calculateStrides< PERMUTATION >( this->m_dims );
  }

  LVARRAY_HOST_DEVICE
  inline void setSingleParameterResizeIndex( int const index )
  {
    LVARRAY_ERROR_IF_LT( index, 0 );
    LVARRAY_ERROR_IF_GE( index, NDIM );
    this->m_singleParameterResizeIndex = index;
  }



  void reserve( INDEX_TYPE const newCapacity )
  { bufferManipulation::reserve( this->m_dataBuffer, this->size(), MemorySpace::host, newCapacity ); }



  template< typename ... ARGS, int _NDIM=NDIM >
  std::enable_if_t< _NDIM == 1 >
  emplace_back( ARGS && ... args )
  {
    bufferManipulation::emplaceBack( this->m_dataBuffer, this->size(), std::forward< ARGS >( args ) ... );
    ++this->m_dims[ 0 ];
  }

  template< typename ... ARGS, int _NDIM=NDIM >
  std::enable_if_t< _NDIM == 1 >
  emplace( INDEX_TYPE const pos, ARGS && ... args )
  {
    bufferManipulation::emplace( this->m_dataBuffer, this->size(), pos, std::forward< ARGS >( args ) ... );
    ++this->m_dims[ 0 ];
  }

  template< typename ITER, int _NDIM=NDIM >
  std::enable_if_t< _NDIM == 1 >
  insert( INDEX_TYPE const pos, ITER const first, ITER const last )
  { this->m_dims[ 0 ] += bufferManipulation::insert( this->m_dataBuffer, this->size(), pos, first, last ); }

  template< int _NDIM=NDIM >
  std::enable_if_t< _NDIM == 1 >
  pop_back()
  {
    bufferManipulation::popBack( this->m_dataBuffer, this->size() );
    --this->m_dims[ 0 ];
  }

  template< int _NDIM=NDIM >
  std::enable_if_t< _NDIM == 1 >
  erase( INDEX_TYPE const pos )
  {
    bufferManipulation::erase( this->m_dataBuffer, this->size(), pos );
    --this->m_dims[ 0 ];
  }


  void setName( std::string const & name )
  { this->m_dataBuffer.template setName< decltype(*this) >( name ); }

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

  static int TV_ttf_display_type( Array const * av )
  {
    return ParentClass::TV_ttf_display_type( av );
  }
#endif

private:

  DISABLE_HD_WARNING
  template< typename ... ARGS >
  LVARRAY_HOST_DEVICE
  void resizeDefaultDimension( INDEX_TYPE const newDimLength, ARGS && ... args )
  {
    LVARRAY_ERROR_IF_LT( newDimLength, 0 );

    // If m_singleParameterResizeIndex is the first dimension in memory than a simple 1D resizing is sufficient. The
    // check if NDIM == 1 is to give the compiler compile time knowledge that this path is always taken for 1D arrays.
    if( NDIM == 1 || typeManipulation::asArray( PERMUTATION {} )[ 0 ] == this->m_singleParameterResizeIndex )
    {
      INDEX_TYPE const oldSize = this->size();
      this->m_dims[ this->m_singleParameterResizeIndex ] = newDimLength;
      this->m_strides = indexing::calculateStrides< PERMUTATION >( this->m_dims );

      bufferManipulation::resize( this->m_dataBuffer, oldSize, this->size(), std::forward< ARGS >( args )... );
      return;
    }

    // Get the current length and stride of the dimension as well as the size of the whole Array.
    INDEX_TYPE const curDimLength = this->m_dims[ this->m_singleParameterResizeIndex ];
    INDEX_TYPE const curDimStride = this->m_strides[ this->m_singleParameterResizeIndex ];
    INDEX_TYPE const curSize = this->size();

    // Set the size of the dimension, recalculate the strides and get the new total size.
    this->m_dims[ this->m_singleParameterResizeIndex ] = newDimLength;
    this->m_strides = indexing::calculateStrides< PERMUTATION >( this->m_dims );

    INDEX_TYPE const newSize = this->size();

    // If we aren't changing the total size then we can return early.
    if( newSize == curSize ) return;

    // If the size is increasing do one thing, if it's decreasing do another.
    if( newDimLength > curDimLength )
    {
      // Reserve space in the buffer but don't initialize the values.
      bufferManipulation::reserve( this->m_dataBuffer, curSize, MemorySpace::host, newSize );
      T * const ptr = this->data();

      // The resizing consists of iterations where each iteration consists of the addition of a
      // contiguous segment of new values.
      INDEX_TYPE const valuesToAddPerIteration = curDimStride * ( newDimLength - curDimLength );
      INDEX_TYPE const valuesToShiftPerIteration = curDimStride * curDimLength;
      INDEX_TYPE const numIterations = ( newSize - curSize ) / valuesToAddPerIteration;

      // Iterate backwards over the iterations.
      for( INDEX_TYPE i = numIterations - 1; i >= 0; --i )
      {
        // First shift the values up to make remove for the values of subsequent iterations.
        // This step is a no-op on the last iteration (i=0).
        INDEX_TYPE const valuesLeftToInsert = valuesToAddPerIteration * i;
        T * const startOfShift = ptr + valuesToShiftPerIteration * i;
        arrayManipulation::shiftUp( startOfShift, valuesToShiftPerIteration, INDEX_TYPE( 0 ), valuesLeftToInsert );

        // Initialize the new values.
        T * const startOfNewValues = startOfShift + valuesToShiftPerIteration + valuesLeftToInsert;
        for( INDEX_TYPE j = 0; j < valuesToAddPerIteration; ++j )
        {
          new ( startOfNewValues + j ) T( args ... );
        }
      }
    }
    else
    {
      T * const ptr = this->data();

      // The resizing consists of iterations where each iteration consists of the removal of a
      // contiguous segment of new values.
      INDEX_TYPE const valuesToRemovePerIteration = curDimStride * ( curDimLength - newDimLength );
      INDEX_TYPE const valuesToShiftPerIteration = curDimStride * newDimLength;
      INDEX_TYPE const numIterations = ( curSize - newSize ) / valuesToRemovePerIteration;

      // Iterate over the iterations, skipping the first.
      for( INDEX_TYPE i = 1; i < numIterations; ++i )
      {
        INDEX_TYPE const amountToShift = valuesToRemovePerIteration * i;
        T * const startOfShift = ptr + valuesToShiftPerIteration * i;
        arrayManipulation::shiftDown( startOfShift,
                                      valuesToShiftPerIteration + amountToShift,
                                      amountToShift, amountToShift );
      }

      // After the iterations are complete all the values to remove have been moved to the end of the array.
      // We destroy them here.
      INDEX_TYPE const totalValuesToRemove = valuesToRemovePerIteration * numIterations;
      for( INDEX_TYPE i = 0; i < totalValuesToRemove; ++i )
      {
        ptr[ newSize + i ].~T();
      }
    }
  }
};

template< typename >
constexpr bool isArray = false;

template< typename T,
          int NDIM,
          typename PERMUTATION,
          typename INDEX_TYPE,
          template< typename > class BUFFER_TYPE >
constexpr bool isArray< Array< T, NDIM, PERMUTATION, INDEX_TYPE, BUFFER_TYPE > > = true;

namespace internal
{

// Since Array expects the BUFFER to only except a single template parameter we need to
// create an alias for a StackBuffer with a given length.
template< typename T,
          int NDIM,
          typename PERMUTATION,
          typename INDEX_TYPE,
          int LENGTH >
struct StackArrayHelper
{
  template< typename U >
  using BufferType = StackBuffer< U, LENGTH >;

  using type = Array< T, NDIM, PERMUTATION, INDEX_TYPE, BufferType >;
};

} // namespace internal

template< typename T,
          int NDIM,
          typename PERMUTATION,
          typename INDEX_TYPE,
          int LENGTH >
using StackArray = typename internal::StackArrayHelper< T, NDIM, PERMUTATION, INDEX_TYPE, LENGTH >::type;

} /* namespace LvArray */