memcpy.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 "ArrayView.hpp"
#include "umpireInterface.hpp"

// System includes
#include <cstring>

namespace LvArray
{

namespace internal
{

template< int N_LEFT, typename T, int NDIM, int USD, typename INDEX_TYPE >
std::enable_if_t< N_LEFT == 0, ArraySlice< T, NDIM, USD, INDEX_TYPE > >
slice( ArraySlice< T, NDIM, USD, INDEX_TYPE > const curSlice, INDEX_TYPE const * )
{ return curSlice; }

template< int N_LEFT, typename T, int NDIM, int USD, typename INDEX_TYPE >
std::enable_if_t< N_LEFT != 0, ArraySlice< T, NDIM - N_LEFT, USD - N_LEFT, INDEX_TYPE > >
slice( ArraySlice< T, NDIM, USD, INDEX_TYPE > const curSlice, INDEX_TYPE const * const remainingIndices )
{ return slice< N_LEFT - 1 >( curSlice[ remainingIndices[ 0 ] ], remainingIndices + 1 ); }

} // namespace internal

template< typename T, int NDIM, int USD, typename DST_INDEX_TYPE, typename SRC_INDEX_TYPE >
void memcpy( ArraySlice< T, NDIM, USD, DST_INDEX_TYPE > const dst,
             ArraySlice< T const, NDIM, USD, SRC_INDEX_TYPE > const src )
{
  LVARRAY_ERROR_IF_NE( dst.size(), src.size() );

  for( int i = 0; i < NDIM; ++i )
  {
    LVARRAY_ERROR_IF_NE( dst.stride( i ), src.stride( i ) );
  }

  T * const dstPointer = dst.dataIfContiguous();
  T * const srcPointer = const_cast< T * >( src.dataIfContiguous() );
  std::size_t numBytes = dst.size() * sizeof( T );

  umpireInterface::copy( dstPointer, srcPointer, numBytes );
}

template< typename T, int NDIM, int USD, typename DST_INDEX_TYPE, typename SRC_INDEX_TYPE >
camp::resources::Event memcpy( camp::resources::Resource & resource,
                               ArraySlice< T, NDIM, USD, DST_INDEX_TYPE > const dst,
                               ArraySlice< T const, NDIM, USD, SRC_INDEX_TYPE > const src )
{
  LVARRAY_ERROR_IF_NE( dst.size(), src.size() );

  for( int i = 0; i < NDIM; ++i )
  {
    LVARRAY_ERROR_IF_NE( dst.stride( i ), src.stride( i ) );
  }

  T * const dstPointer = dst.dataIfContiguous();
  T * const srcPointer = const_cast< T * >( src.dataIfContiguous() );
  std::size_t numBytes = dst.size() * sizeof( T );

  return umpireInterface::copy( dstPointer, srcPointer, resource, numBytes );
}

template< std::size_t N_DST_INDICES, std::size_t N_SRC_INDICES, typename T, int DST_NDIM, int DST_USD,
          typename DST_INDEX_TYPE, template< typename > class DST_BUFFER, int SRC_NDIM, int SRC_USD,
          typename SRC_INDEX_TYPE, template< typename > class SRC_BUFFER >
void memcpy( ArrayView< T, DST_NDIM, DST_USD, DST_INDEX_TYPE, DST_BUFFER > const & dst,
             std::array< DST_INDEX_TYPE, N_DST_INDICES > const & dstIndices,
             ArrayView< T const, SRC_NDIM, SRC_USD, SRC_INDEX_TYPE, SRC_BUFFER > const & src,
             std::array< SRC_INDEX_TYPE, N_SRC_INDICES > const & srcIndices )
{
#if !defined( LVARRAY_USE_UMPIRE )
  LVARRAY_ERROR_IF_NE_MSG( dst.getPreviousSpace(), MemorySpace::host, "Without Umpire only host memory is supported." );
  LVARRAY_ERROR_IF_NE_MSG( src.getPreviousSpace(), MemorySpace::host, "Without Umpire only host memory is supported." );
#endif

  dst.move( dst.getPreviousSpace(), true );
  src.move( src.getPreviousSpace(), false );

  ArraySlice< T, DST_NDIM - N_DST_INDICES, DST_USD - N_DST_INDICES, DST_INDEX_TYPE > const dstSlice =
    internal::slice< N_DST_INDICES >( dst.toSlice(), dstIndices.data() );

  ArraySlice< T const, SRC_NDIM - N_SRC_INDICES, SRC_USD - N_SRC_INDICES, SRC_INDEX_TYPE > const srcSlice =
    internal::slice< N_SRC_INDICES >( src.toSlice(), srcIndices.data() );

  memcpy( dstSlice, srcSlice );
}

template< std::size_t N_DST_INDICES, std::size_t N_SRC_INDICES, typename T, int DST_NDIM, int DST_USD,
          typename DST_INDEX_TYPE, template< typename > class DST_BUFFER, int SRC_NDIM, int SRC_USD,
          typename SRC_INDEX_TYPE, template< typename > class SRC_BUFFER >
camp::resources::Event memcpy( camp::resources::Resource & resource,
                               ArrayView< T, DST_NDIM, DST_USD, DST_INDEX_TYPE, DST_BUFFER > const & dst,
                               std::array< DST_INDEX_TYPE, N_DST_INDICES > const & dstIndices,
                               ArrayView< T const, SRC_NDIM, SRC_USD, SRC_INDEX_TYPE, SRC_BUFFER > const & src,
                               std::array< SRC_INDEX_TYPE, N_SRC_INDICES > const & srcIndices )
{
  dst.move( dst.getPreviousSpace(), true );
  src.move( src.getPreviousSpace(), false );

  ArraySlice< T, DST_NDIM - N_DST_INDICES, DST_USD - N_DST_INDICES, DST_INDEX_TYPE > const dstSlice =
    internal::slice< N_DST_INDICES >( dst.toSlice(), dstIndices.data() );

  ArraySlice< T const, SRC_NDIM - N_SRC_INDICES, SRC_USD - N_SRC_INDICES, SRC_INDEX_TYPE > const srcSlice =
    internal::slice< N_SRC_INDICES >( src.toSlice(), srcIndices.data() );

  return memcpy( resource, dstSlice, srcSlice );
}

} // namespace LvArray