ArrayOfArraysView.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 "bufferManipulation.hpp"
#include "arrayManipulation.hpp"
#include "sortedArrayManipulation.hpp"
#include "ArraySlice.hpp"
#include "typeManipulation.hpp"
#include "math.hpp"
#include "umpireInterface.hpp"

// TPL includes
#include <RAJA/RAJA.hpp>

// System includes
#include <cstring>

#ifdef LVARRAY_BOUNDS_CHECK

#define ARRAYOFARRAYS_CHECK_BOUNDS( i ) \
  LVARRAY_ERROR_IF( !arrayManipulation::isPositive( i ) || i >= this->size(), \
                    "Bounds Check Failed: i=" << i << " size()=" << this->size() )

#define ARRAYOFARRAYS_CHECK_BOUNDS2( i, j ) \
  LVARRAY_ERROR_IF( !arrayManipulation::isPositive( i ) || i >= this->size() || \
                    !arrayManipulation::isPositive( j ) || j >= this->m_sizes[ i ], \
                    "Bounds Check Failed: i=" << i << " size()=" << this->size() << \
                    " j=" << j << " m_sizes[ i ]=" << this->m_sizes[ i ] )

#define ARRAYOFARRAYS_CHECK_INSERT_BOUNDS( i ) \
  LVARRAY_ERROR_IF( !arrayManipulation::isPositive( i ) || i > this->size(), \
                    "Insert Bounds Check Failed: i=" << i << " size()=" << this->size() )

#define ARRAYOFARRAYS_CHECK_INSERT_BOUNDS2( i, j ) \
  LVARRAY_ERROR_IF( !arrayManipulation::isPositive( i ) || i >= this->size() || \
                    !arrayManipulation::isPositive( j ) || j > this->sizeOfArray( i ), \
                    "Insert Bounds Check Failed: i=" << i << " size()=" << this->size() << \
                    " j=" << j << " sizeOfArray( i )=" << this->sizeOfArray( i ) )

#define ARRAYOFARRAYS_CAPACITY_CHECK( i, increase ) \
  LVARRAY_ERROR_IF( this->sizeOfArray( i ) + increase > this->capacityOfArray( i ), \
                    "Capacity Check Failed: i=" << i << " increase=" << increase << \
                    " sizeOfArray( i )=" << this->sizeOfArray( i ) << " capacityOfArray( i )=" << \
                    this->capacityOfArray( i ) )

#define ARRAYOFARRAYS_ATOMIC_CAPACITY_CHECK( i, previousSize, increase ) \
  LVARRAY_ERROR_IF( previousSize + increase > this->capacityOfArray( i ), \
                    "Capacity Check Failed: i=" << i << " increase=" << increase << \
                    " sizeOfArray( i )=" << previousSize << " capacityOfArray( i )=" << \
                    this->capacityOfArray( i ) )

#else // LVARRAY_BOUNDS_CHECK

#define ARRAYOFARRAYS_CHECK_BOUNDS( i )

#define ARRAYOFARRAYS_CHECK_BOUNDS2( i, j )

#define ARRAYOFARRAYS_CHECK_INSERT_BOUNDS( i )

#define ARRAYOFARRAYS_CHECK_INSERT_BOUNDS2( i, j )

#define ARRAYOFARRAYS_CAPACITY_CHECK( i, increase )

#define ARRAYOFARRAYS_ATOMIC_CAPACITY_CHECK( i, previousSize, increase )

#endif // LVARRAY_BOUNDS_CHECK

namespace LvArray
{

template< typename T,
          typename INDEX_TYPE,
          bool CONST_SIZES,
          template< typename > class BUFFER_TYPE >
class ArrayOfArraysView
{
protected:
  using INDEX_TYPE_NC = std::remove_const_t< INDEX_TYPE >;

  using SIZE_TYPE = std::conditional_t< CONST_SIZES, INDEX_TYPE const, INDEX_TYPE_NC >;

public:
  static_assert( !std::is_const< T >::value || (std::is_const< INDEX_TYPE >::value && CONST_SIZES),
                 "When T is const INDEX_TYPE must also be const and CONST_SIZES must be true" );
  static_assert( std::is_integral< INDEX_TYPE >::value, "INDEX_TYPE must be integral." );

  using ValueType = T;

  using IndexType = INDEX_TYPE;

  using value_type = T;

  using size_type = INDEX_TYPE;


  ArrayOfArraysView() = default;

  ArrayOfArraysView( ArrayOfArraysView const & ) = default;

  LVARRAY_HOST_DEVICE constexpr inline
  ArrayOfArraysView( ArrayOfArraysView && src ):
    m_numArrays( src.m_numArrays ),
    m_offsets( std::move( src.m_offsets ) ),
    m_sizes( std::move( src.m_sizes ) ),
    m_values( std::move( src.m_values ) )
  { src.m_numArrays = 0; }

  LVARRAY_HOST_DEVICE constexpr inline
  ArrayOfArraysView( INDEX_TYPE const numArrays,
                     BUFFER_TYPE< INDEX_TYPE > const & offsets,
                     BUFFER_TYPE< SIZE_TYPE > const & sizes,
                     BUFFER_TYPE< T > const & values ):
    m_numArrays( numArrays ),
    m_offsets( offsets ),
    m_sizes( sizes ),
    m_values( values )
  {}

  inline
  ArrayOfArraysView & operator=( ArrayOfArraysView const & ) = default;

  inline
  ArrayOfArraysView & operator=( ArrayOfArraysView && src )
  {
    m_numArrays = src.m_numArrays;
    src.m_numArrays = 0;
    m_offsets = std::move( src.m_offsets );
    m_sizes = std::move( src.m_sizes );
    m_values = std::move( src.m_values );
    return *this;
  }



  LVARRAY_HOST_DEVICE constexpr inline
  ArrayOfArraysView< T, INDEX_TYPE const, CONST_SIZES, BUFFER_TYPE >
  toView() const
  {
    return ArrayOfArraysView< T, INDEX_TYPE const, CONST_SIZES, BUFFER_TYPE >( size(),
                                                                               this->m_offsets,
                                                                               this->m_sizes,
                                                                               this->m_values );
  }

  LVARRAY_HOST_DEVICE constexpr inline
  ArrayOfArraysView< T, INDEX_TYPE const, true, BUFFER_TYPE >
  toViewConstSizes() const
  {
    return ArrayOfArraysView< T, INDEX_TYPE const, true, BUFFER_TYPE >( size(),
                                                                        this->m_offsets,
                                                                        this->m_sizes,
                                                                        this->m_values );
  }

  LVARRAY_HOST_DEVICE constexpr inline
  ArrayOfArraysView< T const, INDEX_TYPE const, true, BUFFER_TYPE >
  toViewConst() const
  {
    return ArrayOfArraysView< T const, INDEX_TYPE const, true, BUFFER_TYPE >( size(),
                                                                              this->m_offsets,
                                                                              this->m_sizes,
                                                                              this->m_values );
  }



  LVARRAY_HOST_DEVICE constexpr inline
  INDEX_TYPE_NC size() const
  { return m_numArrays; }

  LVARRAY_HOST_DEVICE CONSTEXPR_WITHOUT_BOUNDS_CHECK inline
  INDEX_TYPE_NC sizeOfArray( INDEX_TYPE const i ) const
  {
    ARRAYOFARRAYS_CHECK_BOUNDS( i );
    return m_sizes[ i ];
  }

  LVARRAY_HOST_DEVICE constexpr inline
  SIZE_TYPE const * getSizes() const
  {
    return m_sizes.data();
  }


  LVARRAY_HOST_DEVICE constexpr inline
  INDEX_TYPE const * getOffsets() const
  {
    return m_offsets.data();
  }

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



  LVARRAY_HOST_DEVICE CONSTEXPR_WITH_NDEBUG inline
  INDEX_TYPE_NC capacity() const
  {
    LVARRAY_ASSERT( m_sizes.capacity() < m_offsets.capacity());
    return m_sizes.capacity();
  }

  LVARRAY_HOST_DEVICE CONSTEXPR_WITHOUT_BOUNDS_CHECK inline
  INDEX_TYPE_NC capacityOfArray( INDEX_TYPE const i ) const
  {
    ARRAYOFARRAYS_CHECK_BOUNDS( i );
    return m_offsets[ i + 1 ] - m_offsets[ i ];
  }

  LVARRAY_HOST_DEVICE constexpr inline
  INDEX_TYPE_NC valueCapacity() const
  { return m_values.capacity(); }



  LVARRAY_HOST_DEVICE CONSTEXPR_WITHOUT_BOUNDS_CHECK inline
  ArraySlice< T, 1, 0, INDEX_TYPE_NC > operator[]( INDEX_TYPE const i ) const
  {
    ARRAYOFARRAYS_CHECK_BOUNDS( i );
    return ArraySlice< T, 1, 0, INDEX_TYPE_NC >( m_values.data() + m_offsets[ i ], &m_sizes[ i ], nullptr );
  }

  LVARRAY_HOST_DEVICE CONSTEXPR_WITHOUT_BOUNDS_CHECK inline
  T & operator()( INDEX_TYPE const i, INDEX_TYPE const j ) const
  {
    ARRAYOFARRAYS_CHECK_BOUNDS2( i, j );
    return m_values[m_offsets[ i ] + j];
  }



  template< typename ... ARGS >
  LVARRAY_HOST_DEVICE inline
  void emplaceBack( INDEX_TYPE const i, ARGS && ... args ) const
  {
    ARRAYOFARRAYS_CHECK_BOUNDS( i );
    ARRAYOFARRAYS_CAPACITY_CHECK( i, 1 );

    T * const ptr = m_values.data() + m_offsets[ i ];
    arrayManipulation::emplaceBack( ptr, sizeOfArray( i ), std::forward< ARGS >( args ) ... );
    m_sizes[ i ] += 1;
  }

  template< typename POLICY, typename ... ARGS >
  LVARRAY_HOST_DEVICE inline
  void emplaceBackAtomic( INDEX_TYPE const i, ARGS && ... args ) const
  {
    ARRAYOFARRAYS_CHECK_BOUNDS( i );

    T * const ptr = m_values.data() + m_offsets[ i ];
    INDEX_TYPE const previousSize = RAJA::atomicInc< POLICY >( &m_sizes[ i ] );
    ARRAYOFARRAYS_ATOMIC_CAPACITY_CHECK( i, previousSize, 1 );

    arrayManipulation::emplaceBack( ptr, previousSize, std::forward< ARGS >( args ) ... );
  }

  template< typename ITER >
  LVARRAY_HOST_DEVICE inline
  void appendToArray( INDEX_TYPE const i, ITER const first, ITER const last ) const
  {
    ARRAYOFARRAYS_CHECK_BOUNDS( i );

    T * const ptr = m_values.data() + m_offsets[ i ];
    INDEX_TYPE const n = arrayManipulation::append( ptr, sizeOfArray( i ), first, last );
    ARRAYOFARRAYS_CAPACITY_CHECK( i, n );
    m_sizes[ i ] += n;
  }

  template< typename ... ARGS >
  LVARRAY_HOST_DEVICE inline
  void emplace( INDEX_TYPE const i, INDEX_TYPE const j, ARGS && ... args ) const
  {
    ARRAYOFARRAYS_CHECK_INSERT_BOUNDS2( i, j );
    ARRAYOFARRAYS_CAPACITY_CHECK( i, 1 );

    T * const ptr = m_values.data() + m_offsets[ i ];
    arrayManipulation::emplace( ptr, sizeOfArray( i ), j, std::forward< ARGS >( args )... );
    m_sizes[ i ]++;
  }

  template< typename ITER >
  LVARRAY_HOST_DEVICE inline
  void insertIntoArray( INDEX_TYPE const i,
                        INDEX_TYPE const j,
                        ITER const first,
                        ITER const last ) const
  {
    ARRAYOFARRAYS_CHECK_INSERT_BOUNDS2( i, j );
    INDEX_TYPE const n = arrayManipulation::iterDistance( first, last );
    ARRAYOFARRAYS_CAPACITY_CHECK( i, n );

    T * const ptr = m_values.data() + m_offsets[ i ];
    arrayManipulation::insert( ptr, sizeOfArray( i ), j, first, n );
    m_sizes[ i ] += n;
  }

  LVARRAY_HOST_DEVICE inline
  void eraseFromArray( INDEX_TYPE const i, INDEX_TYPE const j, INDEX_TYPE const n=1 ) const
  {
    ARRAYOFARRAYS_CHECK_BOUNDS2( i, j );

    T * const ptr = m_values.data() + m_offsets[ i ];
    arrayManipulation::erase( ptr, sizeOfArray( i ), j, n );
    m_sizes[ i ] -= n;
  }



  void registerTouch( MemorySpace const space ) const
  {
    m_values.registerTouch( space );
    m_sizes.registerTouch( space );
    m_offsets.registerTouch( space );
  }

  void move( MemorySpace const space, bool touch=true ) const
  {
    m_values.move( space, touch );
    m_sizes.move( space, touch );

  #if defined(LVARRAY_USE_CUDA)
    if( space == MemorySpace::cuda ) touch = false;
  #endif
    m_offsets.move( space, touch );
  }



protected:

  template< typename U >
  using PairOfBuffers = std::pair< BUFFER_TYPE< U > &, BUFFER_TYPE< U > const & >;

  ArrayOfArraysView( bool ):
    m_numArrays( 0 ),
    m_offsets( true ),
    m_sizes( true ),
    m_values( true )
  {}


  void resize( INDEX_TYPE const newSize, INDEX_TYPE const defaultArrayCapacity=0 )
  { return resizeImpl( newSize, defaultArrayCapacity ); }

  void reserve( INDEX_TYPE const newCapacity )
  {
    bufferManipulation::reserve( m_offsets, m_numArrays + 1, MemorySpace::host, newCapacity + 1 );
    bufferManipulation::reserve( m_sizes, m_numArrays, MemorySpace::host, newCapacity );
  }

  template< class ... BUFFERS >
  void reserveValues( INDEX_TYPE const newValueCapacity, BUFFERS & ... buffers )
  {
    INDEX_TYPE const maxOffset = m_offsets[ m_numArrays ];
    typeManipulation::forEachArg( [newValueCapacity, maxOffset] ( auto & buffer )
    {
      bufferManipulation::reserve( buffer, maxOffset, MemorySpace::host, newValueCapacity );
    }, m_values, buffers ... );
  }

  template< class ... BUFFERS >
  void compress( BUFFERS & ... buffers )
  {
    if( m_numArrays == 0 ) return;

    for( INDEX_TYPE i = 0; i < m_numArrays - 1; ++i )
    {
      INDEX_TYPE const nextOffset = m_offsets[ i + 1 ];
      INDEX_TYPE const shiftAmount = nextOffset - m_offsets[ i ] - sizeOfArray( i );
      INDEX_TYPE const sizeOfNextArray = sizeOfArray( i + 1 );

      // Shift the values in the next array down.
      typeManipulation::forEachArg(
        [sizeOfNextArray, nextOffset, shiftAmount] ( auto & buffer )
      {
        arrayManipulation::uninitializedShiftDown( &buffer[ nextOffset ], sizeOfNextArray, shiftAmount );
      }, m_values, buffers ... );

      // And update the offsets.
      m_offsets[ i + 1 ] -= shiftAmount;
    }

    // Update the last offset.
    m_offsets[ m_numArrays ] = m_offsets[ m_numArrays - 1 ] + sizeOfArray( m_numArrays - 1 );
  }

  template< typename ... BUFFERS >
  void resizeFromOffsets( INDEX_TYPE const numSubArrays,
                          INDEX_TYPE const * const offsets,
                          BUFFERS & ... buffers )
  {
    auto const fillOffsets = [&]()
    {
      arrayManipulation::uninitializedCopy( offsets,
                                            offsets + numSubArrays + 1,
                                            m_offsets.data() );
    };
    resizeFromOffsetsImpl( numSubArrays, fillOffsets, buffers ... );
  }

  template< typename POLICY, typename ... BUFFERS >
  void resizeFromCapacities( INDEX_TYPE const numSubArrays,
                             INDEX_TYPE const * const capacities,
                             BUFFERS & ... buffers )
  {
    auto const fillOffsets = [&]()
    {
      m_offsets[ 0 ] = 0;
//      RAJA::inclusive_scan< POLICY >( capacities,
//                                      capacities + numSubArrays,
//                                      m_offsets.data() + 1 );

      RAJA::inclusive_scan< POLICY >( RAJA::make_span< INDEX_TYPE const * >( capacities, numSubArrays ),
                                      RAJA::make_span< INDEX_TYPE * >( m_offsets.data()+1, numSubArrays ) );
    };
    resizeFromOffsetsImpl( numSubArrays, fillOffsets, buffers ... );
  }



  void assimilate( ArrayOfArraysView< T, INDEX_TYPE, CONST_SIZES, BUFFER_TYPE > && src )
  { *this = std::move( src ); }

  template< typename ... BUFFERS >
  void resizeImpl( INDEX_TYPE const newSize, INDEX_TYPE const defaultArrayCapacity, BUFFERS & ... buffers )
  {
    LVARRAY_ASSERT( arrayManipulation::isPositive( newSize ) );

    INDEX_TYPE const offsetsSize = ( m_numArrays == 0 ) ? 0 : m_numArrays + 1;

    if( newSize < m_numArrays )
    {
      destroyValues( newSize, m_numArrays, buffers ... );
      bufferManipulation::resize( m_offsets, offsetsSize, newSize + 1, 0 );
      bufferManipulation::resize( m_sizes, m_numArrays, newSize, 0 );
    }
    else
    {
      // The ternary here accounts for the case where m_offsets hasn't been allocated yet (when calling from a
      // constructor).
      INDEX_TYPE const originalOffset = (m_numArrays == 0) ? 0 : m_offsets[m_numArrays];
      bufferManipulation::resize( m_offsets, offsetsSize, newSize + 1, originalOffset );
      bufferManipulation::resize( m_sizes, m_numArrays, newSize, 0 );

      if( defaultArrayCapacity > 0 )
      {
        for( INDEX_TYPE i = 1; i < newSize + 1 - m_numArrays; ++i )
        {
          m_offsets[ m_numArrays + i ] = originalOffset + i * defaultArrayCapacity;
        }

        INDEX_TYPE const totalSize = m_offsets[ newSize ];

        INDEX_TYPE const maxOffset = m_offsets[ m_numArrays ];
        typeManipulation::forEachArg( [totalSize, maxOffset]( auto & buffer )
        {
          bufferManipulation::reserve( buffer, maxOffset, MemorySpace::host, totalSize );
        }, m_values, buffers ... );
      }
    }

    m_numArrays = newSize;
  }

  template< class ... BUFFERS >
  void free( BUFFERS & ... buffers )
  {
    destroyValues( 0, m_numArrays, buffers ... );

    typeManipulation::forEachArg( []( auto & buffer )
    {
      buffer.free();
    }, m_sizes, m_offsets, m_values, buffers ... );

    m_numArrays = 0;
  }

  template< class ... PAIRS_OF_BUFFERS >
  void setEqualTo( INDEX_TYPE const srcNumArrays,
                   INDEX_TYPE const srcMaxOffset,
                   BUFFER_TYPE< INDEX_TYPE > const & srcOffsets,
                   BUFFER_TYPE< INDEX_TYPE > const & srcSizes,
                   BUFFER_TYPE< T > const & srcValues,
                   PAIRS_OF_BUFFERS && ... pairs )
  {
    destroyValues( 0, m_numArrays, pairs.first ... );

    INDEX_TYPE const offsetsSize = ( m_numArrays == 0 ) ? 0 : m_numArrays + 1;

    bufferManipulation::copyInto( m_offsets, offsetsSize, srcOffsets, srcNumArrays + 1 );
    bufferManipulation::copyInto( m_sizes, m_numArrays, srcSizes, srcNumArrays );

    INDEX_TYPE const maxOffset = m_offsets[ m_numArrays ];
    typeManipulation::forEachArg( [maxOffset, srcMaxOffset]( auto & dstBuffer )
    {
      bufferManipulation::reserve( dstBuffer, maxOffset, MemorySpace::host, srcMaxOffset );
    }, m_values, pairs.first ... );

    m_numArrays = srcNumArrays;

    typeManipulation::forEachArg( [this] ( auto & pair )
    {
      auto & dstBuffer = pair.first;
      auto const & srcBuffer = pair.second;

      for( INDEX_TYPE_NC i = 0; i < m_numArrays; ++i )
      {
        INDEX_TYPE const offset = m_offsets[ i ];
        INDEX_TYPE const arraySize = sizeOfArray( i );
        arrayManipulation::uninitializedCopy( &srcBuffer[ offset ],
                                              &srcBuffer[ offset ] + arraySize,
                                              &dstBuffer[ offset ] );
      }
    }, PairOfBuffers< T >( m_values, srcValues ), pairs ... );
  }

  template< class ... BUFFERS >
  void setCapacityOfArray( INDEX_TYPE const i, INDEX_TYPE const newCapacity, BUFFERS & ... buffers )
  {
    ARRAYOFARRAYS_CHECK_BOUNDS( i );
    LVARRAY_ASSERT( arrayManipulation::isPositive( newCapacity ) );

    INDEX_TYPE const arrayCapacity = capacityOfArray( i );
    INDEX_TYPE const capacityIncrease = newCapacity - arrayCapacity;
    if( capacityIncrease == 0 ) return;

    if( capacityIncrease > 0 )
    {
      INDEX_TYPE const maxOffset = m_offsets[ m_numArrays ];
      typeManipulation::forEachArg(
        [this, i, maxOffset, capacityIncrease]( auto & buffer )
      {
        // Increase the size of the buffer.
        bufferManipulation::dynamicReserve( buffer, maxOffset, maxOffset + capacityIncrease );

        // Shift up the values.
        for( INDEX_TYPE array = m_numArrays - 1; array > i; --array )
        {
          INDEX_TYPE const curArraySize = sizeOfArray( array );
          INDEX_TYPE const curArrayOffset = m_offsets[ array ];
          arrayManipulation::uninitializedShiftUp( &buffer[ curArrayOffset ], curArraySize, capacityIncrease );
        }
      },
        m_values, buffers ...
        );
    }
    else
    {
      INDEX_TYPE const arrayOffset = m_offsets[ i ];
      INDEX_TYPE const capacityDecrease = -capacityIncrease;

      INDEX_TYPE const prevArraySize = sizeOfArray( i );
      INDEX_TYPE const newArraySize = math::min( prevArraySize, newCapacity );

      m_sizes[ i ] = newArraySize;
      typeManipulation::forEachArg(
        [this, i, capacityDecrease, arrayOffset, newArraySize, prevArraySize] ( auto & buffer )
      {
        // Delete the values at the end of the array.
        arrayManipulation::destroy( &buffer[ arrayOffset + newArraySize ], prevArraySize - newArraySize );

        // Shift down the values of subsequent arrays.
        for( INDEX_TYPE array = i + 1; array < m_numArrays; ++array )
        {
          INDEX_TYPE const curArraySize = sizeOfArray( array );
          INDEX_TYPE const curArrayOffset = m_offsets[array];
          arrayManipulation::uninitializedShiftDown( &buffer[ curArrayOffset ], curArraySize, capacityDecrease );
        }
      },
        m_values, buffers ...
        );
    }

    // Update the offsets array
    for( INDEX_TYPE array = i + 1; array < m_numArrays + 1; ++array )
    {
      m_offsets[array] += capacityIncrease;
    }

    // We need to touch the offsets on the CPU because since it contains const data
    // when the ArrayOfArraysView gets copy constructed it doesn't get touched even though
    // it can then be modified via this method when called from a parent non-view class.
    m_offsets.registerTouch( MemorySpace::host );
  }

  template< typename U >
  void setName( std::string const & name )
  {
    m_offsets.template setName< U >( name + "/m_offsets" );
    m_sizes.template setName< U >( name + "/m_sizes" );
    m_values.template setName< U >( name + "/m_values" );
  }


  INDEX_TYPE_NC m_numArrays = 0;

  BUFFER_TYPE< INDEX_TYPE > m_offsets;

  BUFFER_TYPE< SIZE_TYPE > m_sizes;

  BUFFER_TYPE< T > m_values;

private:

  template< class ... BUFFERS >
  void destroyValues( INDEX_TYPE const begin, INDEX_TYPE const end, BUFFERS & ... buffers )
  {
    ARRAYOFARRAYS_CHECK_INSERT_BOUNDS( begin );
    ARRAYOFARRAYS_CHECK_INSERT_BOUNDS( end );

    // If the values aren't trivially destructable then the data needs to be moved back to the host.
    // This moves m_sizes and m_offsets, m_values and buffers are moved inside the loop.
    if( !typeManipulation::all_of_t< std::is_trivially_destructible< T >,
                                     std::is_trivially_destructible< typename BUFFERS::value_type > ... >::value )
    { move( MemorySpace::host, true ); }

    typeManipulation::forEachArg( [this, begin, end] ( auto & buffer )
    {
      if( !std::is_trivially_destructible< std::remove_reference_t< decltype( buffer[ 0 ] ) > >::value )
      {
        buffer.move( MemorySpace::host, true );
        for( INDEX_TYPE i = begin; i < end; ++i )
        {
          INDEX_TYPE const offset = m_offsets[ i ];
          INDEX_TYPE const arraySize = sizeOfArray( i );
          arrayManipulation::destroy( &buffer[ offset ], arraySize );
        }
      }
    }, m_values, buffers ... );
  }

  template< typename FUNC, typename ... BUFFERS >
  void resizeFromOffsetsImpl( INDEX_TYPE const numSubArrays,
                              FUNC && fillOffsets,
                              BUFFERS & ... buffers )
  {
    LVARRAY_ASSERT( arrayManipulation::isPositive( numSubArrays ) );

    destroyValues( 0, m_numArrays, buffers ... );

    bufferManipulation::reserve( m_sizes, m_numArrays, MemorySpace::host, numSubArrays );
    umpireInterface::memset( m_sizes.data(), 0, m_sizes.capacity() * sizeof( INDEX_TYPE ) );

    INDEX_TYPE const offsetsSize = ( m_numArrays == 0 ) ? 0 : m_numArrays + 1;
    bufferManipulation::reserve( m_offsets, offsetsSize, MemorySpace::host, numSubArrays + 1 );

    fillOffsets();
    LVARRAY_ASSERT_EQ( m_offsets[0], 0 );
    LVARRAY_ASSERT( sortedArrayManipulation::isSorted( m_offsets.data(), m_offsets.data() + numSubArrays + 1 ) );

    m_numArrays = numSubArrays;
    INDEX_TYPE const maxOffset = m_offsets[ m_numArrays ];
    typeManipulation::forEachArg( [ maxOffset ] ( auto & buffer )
    {
      bufferManipulation::reserve( buffer, 0, MemorySpace::host, maxOffset );
    }, m_values, buffers ... );
  }
};

} /* namespace LvArray */