AlignedAllocator.h

Go to the documentation of this file.

#ifndef MiscLib__ALIGNEDALLOCATOR_HEADER__
#define MiscLib__ALIGNEDALLOCATOR_HEADER__
#include <limits>
#include <memory>
 
#include <malloc.h>
#include <xmmintrin.h>
#ifdef max
#undef max
#endif
 
namespace MiscLib
{
 
    enum
    {
        DefaultAlignment = sizeof(size_t)
    };
 
    template <class T, unsigned int Align = DefaultAlignment>
    class AlignedAllocator
    {
    public:
        typedef size_t size_type;
        typedef ptrdiff_t difference_type;
        typedef T* pointer;
        typedef const T* const_pointer;
        typedef T& reference;
        typedef const T& const_reference;
        typedef T value_type;
 
        template <class U>
        struct rebind
        {
            typedef AlignedAllocator<U, Align> other;
        };
 
        AlignedAllocator() throw()
        {
        }
 
        AlignedAllocator(const AlignedAllocator<T, Align>&) throw()
        {
        }
 
        template <class U>
        AlignedAllocator(const AlignedAllocator<U, Align>&) throw()
        {
        }
 
        pointer
        address(reference x) const
        {
            return &x;
        }
 
        const_pointer
        address(const_reference x) const
        {
            return &x;
        }
 
        pointer
        allocate(size_type s,
                 std::allocator_traits<std::allocator<void>>::const_void_pointer hint = 0)
        {
            return (T*)_mm_malloc(s * sizeof(T), Align);
        }
 
        void
        deallocate(pointer p, size_type)
        {
            _mm_free(p);
        }
 
        size_type
        max_size() const throw()
        {
            return std::numeric_limits<size_type>::max();
        }
 
        void
        construct(pointer p, const T& val)
        {
            new (static_cast<void*>(p)) T(val);
        }
 
        void
        destroy(pointer p)
        {
            p->~T();
        }
 
        template <class U>
        bool
        operator==(const AlignedAllocator<U, Align>&) const
        {
            return true;
        }
 
        template <class U>
        bool
        operator==(const U&) const
        {
            return false;
        }
 
        template <class U>
        bool
        operator!=(const AlignedAllocator<U, Align>&) const
        {
            return false;
        }
 
        template <class U>
        bool
        operator!=(const U&) const
        {
            return true;
        }
    };
 
    template <unsigned int Align = sizeof(size_t)>
    struct MakeFixedAlignedAllocator
    {
        template <class T>
        struct AllocType : public AlignedAllocator<T, Align>
        {
        };
    };
 
}; // namespace MiscLib
 
#endif