aligned_allocator.h

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
 
#pragma once
 
#include <type_traits>
#include <memory>
 
// This is to match Eigen expectations on alignment of dynamic objects:
#if defined(__AVX2__) || defined(EIGEN_VECTORIZE_AVX512)
#define MRPT_MAX_ALIGN_BYTES 64
#elif defined(__AVX__)
#define MRPT_MAX_ALIGN_BYTES 32
#else
#define MRPT_MAX_ALIGN_BYTES 16
#endif
 
namespace mrpt
{
void* aligned_malloc(size_t size, size_t alignment);
void* aligned_realloc(void* ptr, size_t size, size_t alignment);
void aligned_free(void* ptr);
/** Identical to aligned_malloc, but it zeroes the reserved memory block. */
inline void* aligned_calloc(size_t bytes, size_t alignment);
 
/** Aligned allocator that is compatible with C++11.
 * Default alignment can be 16 (default), 32 (if __AVX__ is defined) or 64
 * (if __AVX2__ is defined).
 * See also: https://bitbucket.org/eigen/eigen/commits/f5b7700
 */
template <class T, size_t AligmentBytes = MRPT_MAX_ALIGN_BYTES>
class aligned_allocator_cpp11 : public std::allocator<T>
{
   public:
        using size_type = std::size_t;
        using difference_type = std::ptrdiff_t;
        using pointer = T*;
        using const_pointer = const T*;
        using reference = T&;
        using const_reference = const T&;
        using value_type = T;
 
        template <class U>
        struct rebind
        {
                using other = aligned_allocator_cpp11<U>;
        };
 
        aligned_allocator_cpp11() : std::allocator<T>() {}
        aligned_allocator_cpp11(const aligned_allocator_cpp11& other)
                : std::allocator<T>(other)
        {
        }
        template <class U>
        aligned_allocator_cpp11(const aligned_allocator_cpp11<U>& other)
                : std::allocator<T>(other)
        {
        }
        ~aligned_allocator_cpp11() {}
        pointer allocate(size_type num, const void* /*hint*/ = nullptr)
        {
                return static_cast<pointer>(
                        mrpt::aligned_malloc(num * sizeof(T), AligmentBytes));
        }
        void deallocate(pointer p, size_type /*num*/) { mrpt::aligned_free(p); }
};
 
/** Creates a `shared_ptr` with aligned memory via aligned_allocator_cpp11<>.
 * \ingroup mrpt_base_grp
 */
template <typename T, class... Args>
std::shared_ptr<T> make_aligned_shared(Args&&... args)
{
        using T_nc = typename std::remove_const<T>::type;
        return std::allocate_shared<T>(
                mrpt::aligned_allocator_cpp11<T_nc>(), std::forward<Args>(args)...);
}
 
/** Put this macro inside any class with members that require {16,32,64}-byte
 * memory alignment (e.g. Eigen matrices), to override default new()/delete().
 * Obviously, this macro is only *required* if the class is to be instantiated
 * in dynamic memory.
 */
#define MRPT_MAKE_ALIGNED_OPERATOR_NEW                                         \
        void* operator new(size_t size)                                            \
        {                                                                          \
                return mrpt::aligned_malloc(size, MRPT_MAX_ALIGN_BYTES);               \
        }                                                                          \
        void* operator new[](size_t size)                                          \
        {                                                                          \
                return mrpt::aligned_malloc(size, MRPT_MAX_ALIGN_BYTES);               \
        }                                                                          \
        void operator delete(void* ptr) noexcept { mrpt::aligned_free(ptr); }      \
        void operator delete[](void* ptr) noexcept { mrpt::aligned_free(ptr); }    \
        /* in-place new and delete. since (at least afaik) there is no actual   */ \
        /* memory allocated we can safely let the default implementation handle */ \
        /* this particular case. */                                                \
        static void* operator new(size_t size, void* ptr)                          \
        {                                                                          \
                return ::operator new(size, ptr);                                      \
        }                                                                          \
        void operator delete(void* memory, void* ptr) noexcept                     \
        {                                                                          \
                return ::operator delete(memory, ptr);                                 \
        }                                                                          \
        /* nothrow-new (returns zero instead of std::bad_alloc) */                 \
        void* operator new(size_t size, const std::nothrow_t&) noexcept            \
        {                                                                          \
                try                                                                    \
                {                                                                      \
                        return mrpt::aligned_malloc(size, MRPT_MAX_ALIGN_BYTES);           \
                }                                                                      \
                catch (...)                                                            \
                {                                                                      \
                        return nullptr;                                                    \
                }                                                                      \
        }                                                                          \
        void operator delete(void* ptr, const std::nothrow_t&)noexcept             \
        {                                                                          \
                mrpt::aligned_free(ptr);                                               \
        }
}  // namespace mrpt