AlignedAllocator.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstdlib>
#include <limits>
#include <new>
#include <utility>
 
namespace autopas {
 
constexpr unsigned int DEFAULT_CACHE_LINE_SIZE{64};
 
template <class T, size_t Alignment = DEFAULT_CACHE_LINE_SIZE>
class AlignedAllocator {
 public:
  // needed for compatibility with stl::allocator
  using value_type = T;
  using pointer = T *;
  using const_pointer = const T *;
  using reference = T &;
  using const_reference = const T &;
  using size_type = size_t;
 
  template <class U>
  struct rebind {
    using other = AlignedAllocator<U, Alignment>;
  };
 
  AlignedAllocator() = default;
 
  template <class U>
  AlignedAllocator(const AlignedAllocator<U, Alignment> &) {}
 
  ~AlignedAllocator() = default;
 
  size_t max_size() const noexcept { return (std::numeric_limits<size_t>::max() - size_t(Alignment)) / sizeof(T); }
 
  T *allocate(std::size_t n) {
    if (n <= max_size()) {
      size_t neededSize = sizeof(T) * n;
      // sizeToRequest has to be a multiple of Alignment!
      static_assert(Alignment > 0, "Alignment must be bigger than 0!");
      // Rounds up to next multiple of Alignment.
      size_t sizeToRequest = ((neededSize + Alignment - 1) / Alignment) * Alignment;
      T *ptr = static_cast<T *>(aligned_alloc(Alignment, sizeToRequest));
      if (ptr == nullptr) {
        throw std::bad_alloc();
      }
      return ptr;
    }
    throw std::bad_alloc();
  }
 
  void deallocate(T *ptr, std::size_t /*n*/) { free(ptr); }
 
  template <class U, class... Args>
  void construct(U *p, Args &&...args) {
    ::new ((void *)p) U(std::forward<Args>(args)...);
  }
 
  template <class U>
  void destroy(U *p) {
    p->~U();
  }
};
 
template <typename T, size_t TAlignment, typename U, size_t UAlignment>
inline bool operator==(const AlignedAllocator<T, TAlignment> &, const AlignedAllocator<U, UAlignment> &) {
  return TAlignment == UAlignment;
}
 
template <typename T, size_t TAlignment, typename U, size_t UAlignment>
inline bool operator!=(const AlignedAllocator<T, TAlignment> &a, const AlignedAllocator<U, UAlignment> &b) {
  return !(a == b);
}
 
}  // namespace autopas