AlignedAllocator.h

 
#ifndef ALIGNEDALLOCATOR_H
#define ALIGNEDALLOCATOR_H
 
#ifdef __SSE3__
#include <xmmintrin.h>
#endif
 
#include <limits>
#include <stdlib.h>
//#include <malloc.h>
 
#define CACHE_LINE_SIZE 64
 
template<typename T, size_t Alignment = CACHE_LINE_SIZE>
struct AlignedAllocator {
 
    typedef T value_type;
    typedef T* pointer;
    typedef const T* const_pointer;
    typedef T& reference;
    typedef const T& const_reference;
    typedef size_t size_type;
 
    //dont know what rebind exactly does
    //but makes the allocator compile with second template parameter
    template<class U>
    struct rebind {
        typedef AlignedAllocator<U, Alignment> other;
    };
 
    AlignedAllocator() = default;
 
    template<class U>
    AlignedAllocator(const AlignedAllocator<U, Alignment>&) {
    }
 
    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()) {
#if defined(_SX)
            T* ptr = static_cast<T*>(malloc(sizeof(T) * n));
#elif defined(__SSE3__) && !defined(__PGI)
            T* ptr = static_cast<T*>(_mm_malloc(sizeof(T) * n, Alignment));
#else
            T* ptr = static_cast<T*>(memalign(Alignment, sizeof(T) * n));
            //T* ptr = static_cast<T*>(aligned_alloc(Alignment, sizeof(T) * n));
            //T* ptr; posix_memalign(&ptr,Alignment, sizeof(T) * n);
#endif
            if (ptr == nullptr) {
                throw std::bad_alloc();
            }
            return ptr;
        }
        throw std::bad_alloc();
    }
 
    void deallocate(T* ptr, std::size_t /*n*/) {
#if defined(__SSE3__) && !defined(__PGI)
        _mm_free(ptr);
#else
        free(ptr);
#endif
    }
 
    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);
}
 
#endif /*ALIGNEDALLOCATOR_H*/