aligned_buffer.hpp

Go to the documentation of this file.

#pragma once
 
#include "initialization.hpp"
 
#include <algorithm>
#include <complex>
#include <cstddef>
#include <cstdlib>
#include <memory>
#include <new>
#include <type_traits>
 
namespace uni20
{
namespace detail
{
 
template <typename T> struct aligned_deleter
{
    void operator()(T* p) const noexcept
    {
      if (!p) return;
#if defined(_MSC_VER)
      _aligned_free(p);
#else
      std::free(p);
#endif
    }
};
 
template <typename T> struct aligned_destructor_deleter
{
    std::size_t count;
    explicit aligned_destructor_deleter(std::size_t n) noexcept : count(n) {}
 
    void operator()(T* p) const noexcept
    {
      if (!p) return;
      // invoke destructor on each element
      for (std::size_t i = 0; i < count; ++i)
      {
        p[i].~T();
      }
#if defined(_MSC_VER)
      _aligned_free(p);
#else
      std::free(p);
#endif
    }
};
 
inline void* allocate_raw(std::size_t bytes, std::size_t align)
{
  void* ptr = nullptr;
#if defined(_MSC_VER)
  ptr = _aligned_malloc(bytes, align);
  if (!ptr) throw std::bad_alloc();
#else
  // posix_memalign only cares that:
  //   - align is pow-2 and ≥ sizeof(void*)
  //   - size can be any value
  if (int err = posix_memalign(&ptr, align, bytes); err)
  {
    throw std::bad_alloc();
  }
#endif
 
  return ptr;
}
 
template <typename T> using aligned_buf_t = std::unique_ptr<T[], aligned_deleter<T>>;
 
template <typename T> using aligned_buf_with_dtor_t = std::unique_ptr<T[], aligned_destructor_deleter<T>>;
 
} // namespace detail
 
template <typename T> detail::aligned_buf_t<T> allocate_uninitialized_buffer(std::size_t N, std::size_t align = 64)
{
  if (N == 0) return detail::aligned_buf_t<T>{nullptr, detail::aligned_deleter<T>{}};
  auto result = detail::aligned_buf_t<T>(static_cast<T*>(detail::allocate_raw(sizeof(T) * N, align)),
                                        detail::aligned_deleter<T>{});
  if constexpr (uninitialized_ok<T>)
  {
    detail::initialize_host_elements(result.get(), N, StorageInitialization::Uninitialized);
  }
  return result;
}
 
template <typename T> auto allocate_temporary_buffer(std::size_t N, std::size_t align = 64)
{
  if constexpr (uninitialized_ok<T>)
  {
    // raw memory, no ctors/dtors
    return allocate_uninitialized_buffer<T>(N, align);
  }
  else
  {
    if (N == 0)
    {
      return detail::aligned_buf_with_dtor_t<T>{nullptr, detail::aligned_destructor_deleter<T>{0}};
    }
    // allocate raw
    void* raw = detail::allocate_raw(sizeof(T) * N, align);
    T* ptr = static_cast<T*>(raw);
 
    // default-construct each element
    for (std::size_t i = 0; i < N; ++i)
    {
      ::new (static_cast<void*>(ptr + i)) T();
    }
 
    // return with deleter that runs dtors then frees
    return detail::aligned_buf_with_dtor_t<T>(ptr, detail::aligned_destructor_deleter<T>{N});
  }
}
 
template <typename T> auto allocate_temporary_buffer_uninitialized(std::size_t N, std::size_t align = 64)
{
  if constexpr (uninitialized_ok<T>)
  {
    // trivially‐copyable → raw storage, no dtors
    return allocate_uninitialized_buffer<T>(N, align);
  }
  else
  {
    if (N == 0)
    {
      return detail::aligned_buf_with_dtor_t<T>{nullptr, detail::aligned_destructor_deleter<T>{0}};
    }
    void* raw = detail::allocate_raw(sizeof(T) * N, align);
    T* ptr = static_cast<T*>(raw);
    // *** no placement‐new here! user must do it. ***
    return detail::aligned_buf_with_dtor_t<T>(ptr, detail::aligned_destructor_deleter<T>{N});
  }
}
 
} // namespace uni20