alloc.H

// ===========================================================================
//
// allocation code
//
// This source code file is part of the following software:
//
//    - the low-level C++ template SIMD library
//    - the SIMD implementation of the MinWarping and the 2D-Warping methods
//      for local visual homing.
//
// The software is provided based on the accompanying license agreement in the
// file LICENSE.md.
// The software is provided "as is" without any warranty by the licensor and
// without any liability of the licensor, and the software may not be
// distributed by the licensee; see the license agreement for details.
//
// (C) Ralf Möller
//     Computer Engineering
//     Faculty of Technology
//     Bielefeld University
//     www.ti.uni-bielefeld.de
//
// ===========================================================================
 
// 30. Aug 22 (Jonas Keller): added simd_aligned_malloc and simd_aligned_free
 
// 02. Mar 23 (Jonas Keller): added doxygen documentation
 
#pragma once
#ifndef SIMDALLOC_H_
#define SIMDALLOC_H_
 
#include "defs.H"
 
#include <cstddef>
#include <utility>
 
#ifdef _WIN32
#include <malloc.h>
#else
#include <cstdlib>
#endif
 
namespace simd {
 
inline void *aligned_malloc(size_t alignment, size_t size)
{
#ifdef _WIN32
  return _aligned_malloc(size, alignment);
#else
  void *ptr = nullptr;
  if (posix_memalign(&ptr, alignment, size) != 0) { return nullptr; }
  return ptr;
#endif
}
 
#if defined(NATIVE_SIMD_WIDTH) || defined(DOXYGEN)
inline void *aligned_malloc(size_t size)
{
  return aligned_malloc(NATIVE_SIMD_WIDTH, size);
}
#endif
 
inline void aligned_free(void *ptr)
{
#ifdef _WIN32
  _aligned_free(ptr);
#else
  free(ptr);
#endif
}
 
// 05. Sep 23 (Jonas Keller): added simd_aligned_allocator
 
#ifdef NATIVE_SIMD_WIDTH
template <typename T, size_t ALIGN = NATIVE_SIMD_WIDTH>
#else
template <typename T, size_t ALIGN>
#endif
class aligned_allocator
{
  // exclude from doxygen (until endcond)
public:
  using value_type      = T;
  using pointer         = T *;
  using const_pointer   = const T *;
  using reference       = T &;
  using const_reference = const T &;
  using size_type       = std::size_t;
  using difference_type = std::ptrdiff_t;
 
  template <typename U>
  struct rebind
  {
    using other = aligned_allocator<U, ALIGN>;
  };
 
  aligned_allocator() noexcept {}
  aligned_allocator(const aligned_allocator &) noexcept {}
  template <typename U>
  aligned_allocator(const aligned_allocator<U, ALIGN> &) noexcept
  {}
  ~aligned_allocator() noexcept {}
 
  pointer address(reference x) const noexcept { return std::addressof(x); }
  const_pointer address(const_reference x) const noexcept
  {
    return std::addressof(x);
  }
 
  pointer allocate(size_type n, const void * = 0)
  {
    return static_cast<pointer>(aligned_malloc(ALIGN, n * sizeof(T)));
  }
  void deallocate(pointer p, size_type) { aligned_free(p); }
 
  size_type max_size() const noexcept
  {
    return (size_type(-1) - size_type(ALIGN)) / sizeof(T);
  }
  template <typename U, typename... Args>
  void construct(U *p, Args &&...args)
  {
    ::new (static_cast<void *>(p)) U(std::forward<Args>(args)...);
  }
  void destroy(pointer p) { p->~T(); }
 
  bool operator==(const aligned_allocator &) const { return true; }
  bool operator!=(const aligned_allocator &) const { return false; }
};
 
} // namespace simd
 
#endif // SIMDALLOC_H_