MallocBuffer.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 "bufferManipulation.hpp"

// System includes
#include <stddef.h>

namespace LvArray
{

template< typename T >
class MallocBuffer : public bufferManipulation::VoidBuffer
{
public:

  using value_type = T;

  static constexpr bool hasShallowCopy = true;

  LVARRAY_HOST_DEVICE inline constexpr
  MallocBuffer( bool=true ):
    m_data( nullptr ),
    m_capacity( 0 )
  {}

  MallocBuffer( MallocBuffer const & ) = default;

  MallocBuffer( MallocBuffer const & src, std::ptrdiff_t ):
    MallocBuffer( src )
  {}

  LVARRAY_HOST_DEVICE inline constexpr
  MallocBuffer( MallocBuffer && src ):
    m_data( src.m_data ),
    m_capacity( src.m_capacity )
  {
    src.m_capacity = 0;
    src.m_data = nullptr;
  }

  template< typename U >
  LVARRAY_HOST_DEVICE inline constexpr
  MallocBuffer( MallocBuffer< U > const & src ):
    m_data( reinterpret_cast< T * >( src.data() ) ),
    m_capacity( typeManipulation::convertSize< T, U >( src.capacity() ) )
  {}

  LVARRAY_HOST_DEVICE inline LVARRAY_INTEL_CONSTEXPR
  MallocBuffer & operator=( MallocBuffer const & src )
  {
    m_capacity = src.m_capacity;
    m_data = src.m_data;
    return *this;
  }

  LVARRAY_HOST_DEVICE inline LVARRAY_INTEL_CONSTEXPR
  MallocBuffer & operator=( MallocBuffer && src )
  {
    m_capacity = src.m_capacity;
    m_data = src.m_data;
    src.m_capacity = 0;
    src.m_data = nullptr;
    return *this;
  }

  void reallocate( std::ptrdiff_t const size, MemorySpace const space, std::ptrdiff_t const newCapacity )
  {
    LVARRAY_ERROR_IF_NE( space, MemorySpace::host );

    // TODO: If std::is_trivially_copyable_v< T > then we could use std::realloc.
    T * const newPtr = reinterpret_cast< T * >( std::malloc( newCapacity * sizeof( T ) ) );

    std::ptrdiff_t const overlapAmount = std::min( newCapacity, size );
    arrayManipulation::uninitializedMove( newPtr, overlapAmount, m_data );
    arrayManipulation::destroy( m_data, size );

    std::free( m_data );
    m_capacity = newCapacity;
    m_data = newPtr;
  }

  LVARRAY_HOST_DEVICE inline
  void free()
  {
    std::free( m_data );
    m_capacity = 0;
    m_data = nullptr;
  }

  LVARRAY_HOST_DEVICE inline
  std::ptrdiff_t capacity() const
  { return m_capacity; }

  LVARRAY_HOST_DEVICE inline constexpr
  T * data() const
  { return m_data; }

  template< typename INDEX_TYPE >
  LVARRAY_HOST_DEVICE inline constexpr
  T & operator[]( INDEX_TYPE const i ) const
  { return m_data[ i ]; }

private:

  T * LVARRAY_RESTRICT m_data = nullptr;

  std::ptrdiff_t m_capacity = 0;
};

} // namespace LvArray