bufferManipulation.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 "LvArrayConfig.hpp"
#include "Macros.hpp"
#include "typeManipulation.hpp"
#include "arrayManipulation.hpp"

// TPL includes
#include <camp/resource.hpp>

// System includes
#include <utility>

namespace LvArray
{

using MemorySpace = camp::resources::Platform;

inline std::ostream & operator<<( std::ostream & os, MemorySpace const space )
{
  if( space == MemorySpace::undefined )
    return os << "undefined";
  if( space == MemorySpace::host )
    return os << "host";
  if( space == MemorySpace::cuda )
    return os << "cuda";
  if( space == MemorySpace::omp_target )
    return os << "omp_target";
  if( space == MemorySpace::hip )
    return os << "hip";
  if( space == MemorySpace::sycl )
    return os << "sycl";

  LVARRAY_ERROR( "Unrecognized memory space " << static_cast< int >( space ) );
  return os;
}

namespace bufferManipulation
{

HAS_MEMBER_FUNCTION_NO_RTYPE( move, MemorySpace::host, true );

struct VoidBuffer
{
  void moveNested( MemorySpace const space, std::ptrdiff_t const size, bool const touch ) const
  {
    LVARRAY_UNUSED_VARIABLE( size );
    LVARRAY_UNUSED_VARIABLE( touch );
    LVARRAY_ERROR_IF_NE_MSG( space, MemorySpace::host, "This Buffer type can only be used on the CPU." );
  }

  void move( MemorySpace const space, bool const touch ) const
  {
    LVARRAY_UNUSED_VARIABLE( touch );
    LVARRAY_ERROR_IF_NE_MSG( space, MemorySpace::host, "This Buffer type can only be used on the CPU." );
  }

  MemorySpace getPreviousSpace() const
  { return MemorySpace::host; }

  void registerTouch( MemorySpace const space ) const
  { LVARRAY_ERROR_IF_NE_MSG( space, MemorySpace::host, "This Buffer type can only be used on the CPU." ); }

  template< typename=VoidBuffer >
  LVARRAY_HOST_DEVICE
  void setName( std::string const & name )
  { LVARRAY_UNUSED_VARIABLE( name ); }
};

template< typename BUFFER >
inline LVARRAY_HOST_DEVICE CONSTEXPR_WITHOUT_BOUNDS_CHECK
void check( BUFFER const & buf, std::ptrdiff_t const size )
{
#ifdef LVARRAY_BOUNDS_CHECK
  LVARRAY_ERROR_IF_GT( 0, buf.capacity() );
  LVARRAY_ERROR_IF_GT( 0, size );
  LVARRAY_ERROR_IF_GT( size, buf.capacity() );
#else
  LVARRAY_DEBUG_VAR( buf );
  LVARRAY_DEBUG_VAR( size );
#endif
}

template< typename BUFFER >
inline
void checkInsert( BUFFER const & buf, std::ptrdiff_t const size, std::ptrdiff_t const pos )
{
#ifdef LVARRAY_BOUNDS_CHECK
  check( buf, size );
  LVARRAY_ERROR_IF_GT( 0, pos );
  LVARRAY_ERROR_IF_GT( pos, size );
#else
  LVARRAY_DEBUG_VAR( buf );
  LVARRAY_DEBUG_VAR( size );
  LVARRAY_DEBUG_VAR( pos );
#endif
}

DISABLE_HD_WARNING
template< typename BUFFER >
LVARRAY_HOST_DEVICE
void free( BUFFER & buf, std::ptrdiff_t const size )
{
  using T = typename BUFFER::value_type;

  check( buf, size );

  if( !std::is_trivially_destructible< T >::value )
  {
    buf.move( MemorySpace::host, true );
    arrayManipulation::destroy( buf.data(), size );
  }

  buf.free();
}

DISABLE_HD_WARNING
template< typename BUFFER >
LVARRAY_HOST_DEVICE
void setCapacity( BUFFER & buf, std::ptrdiff_t const size, MemorySpace const space, std::ptrdiff_t const newCapacity )
{
  check( buf, size );
  buf.reallocate( size, space, newCapacity );
}

template< typename BUFFER >
LVARRAY_HOST_DEVICE
void reserve( BUFFER & buf, std::ptrdiff_t const size, MemorySpace const space, std::ptrdiff_t const newCapacity )
{
  check( buf, size );

  if( newCapacity > buf.capacity() )
  {
    setCapacity( buf, size, space, newCapacity );
  }
}

template< typename BUFFER >
void dynamicReserve( BUFFER & buf, std::ptrdiff_t const size, std::ptrdiff_t const newCapacity )
{
  check( buf, size );

  if( newCapacity > buf.capacity() )
  {
    setCapacity( buf, size, MemorySpace::host, 2 * newCapacity );
  }
}

template< typename BUFFER, typename ... ARGS >
LVARRAY_HOST_DEVICE
void resize( BUFFER & buf, std::ptrdiff_t const size, std::ptrdiff_t const newSize, ARGS && ... args )
{
  check( buf, size );

  reserve( buf, size, MemorySpace::host, newSize );

  arrayManipulation::resize( buf.data(), size, newSize, std::forward< ARGS >( args )... );

#if !defined(LVARRAY_DEVICE_COMPILE)
  if( newSize > 0 )
  {
    buf.registerTouch( MemorySpace::host );
  }
#endif
}

template< typename BUFFER, typename ... ARGS >
void emplaceBack( BUFFER & buf, std::ptrdiff_t const size, ARGS && ... args )
{
  check( buf, size );

  dynamicReserve( buf, size, size + 1 );
  arrayManipulation::emplaceBack( buf.data(), size, std::forward< ARGS >( args ) ... );
}

template< typename BUFFER, typename ... ARGS >
void emplace( BUFFER & buf,
              std::ptrdiff_t const size,
              std::ptrdiff_t const pos,
              ARGS && ... args )
{
  checkInsert( buf, size, pos );

  dynamicReserve( buf, size, size + 1 );
  arrayManipulation::emplace( buf.data(), size, pos, std::forward< ARGS >( args ) ... );
}

template< typename BUFFER, typename ITER >
std::ptrdiff_t insert( BUFFER & buf,
                       std::ptrdiff_t const size,
                       std::ptrdiff_t const pos,
                       ITER const first,
                       ITER const last )
{
  checkInsert( buf, size, pos );

  std::ptrdiff_t const nVals = arrayManipulation::iterDistance( first, last );
  dynamicReserve( buf, size, size + nVals );
  arrayManipulation::insert( buf.data(), size, pos, first, nVals );
  return nVals;
}

template< typename BUFFER >
void popBack( BUFFER & buf, std::ptrdiff_t const size )
{
  check( buf, size );
  arrayManipulation::popBack( buf.data(), size );
}

template< typename BUFFER >
void erase( BUFFER & buf, std::ptrdiff_t const size, std::ptrdiff_t const pos )
{
  check( buf, size );
  LVARRAY_ERROR_IF_GE( pos, size );

  arrayManipulation::erase( buf.data(), size, pos, std::ptrdiff_t( 1 ) );
}

DISABLE_HD_WARNING
template< typename DST_BUFFER, typename SRC_BUFFER >
LVARRAY_HOST_DEVICE
void copyInto( DST_BUFFER & dst,
               std::ptrdiff_t const dstSize,
               SRC_BUFFER const & src,
               std::ptrdiff_t const srcSize )
{
  check( dst, dstSize );
  check( src, srcSize );

  resize( dst, dstSize, srcSize );

  using T = typename DST_BUFFER::value_type;
  T * const LVARRAY_RESTRICT dstData = dst.data();
  T const * const LVARRAY_RESTRICT srcData = src.data();

  for( std::ptrdiff_t i = 0; i < srcSize; ++i )
  {
    dstData[ i ] = srcData[ i ];
  }
}

} // namespace bufferManipulations
} // namespace LvArray