Allocator.hpp

Go to the documentation of this file.

#pragma once
#include "SIMD.hpp"
#include <iostream>
#include <cmath>
#include <vector>
 
#if defined(USE_KNL)
#include <hbwmalloc.h>
#endif
template <typename T, std::size_t Alignment>
struct AlignedAllocator {
    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 = AlignedAllocator<U, Alignment>;
    };
    AlignedAllocator() noexcept = default;
    template <typename U>
    AlignedAllocator(const AlignedAllocator<U, Alignment>&) noexcept {}
    [[nodiscard]] T* allocate(std::size_t n) {
        void* ptr = nullptr;
        const std::size_t alloc_size = n * sizeof(T) + Alignment;
 
#if defined(USE_KNL)
        if (hbw_posix_memalign(&ptr, alignment, alloc_size) != 0)
            throw std::bad_alloc();
#else
        if (posix_memalign(&ptr, Alignment, alloc_size) != 0)
            throw std::bad_alloc();
#endif
        return reinterpret_cast<T*>(ptr);
    }
    void deallocate(T* p, std::size_t) noexcept {
#if defined(USE_KNL)
        hbw_free(p);
#else
        free(p);
#endif
    }
};
template<typename K>
using aligned_vector = std::vector<K, AlignedAllocator<K, ALIGN>>;
 
template <typename T, std::size_t Alignment>
bool operator==(const AlignedAllocator<T, Alignment>&, const AlignedAllocator<T, Alignment>&) noexcept {
    return true;
}
template <typename T, std::size_t Alignment>
bool operator!=(const AlignedAllocator<T, Alignment>&, const AlignedAllocator<T, Alignment>&) noexcept {
    return false;
}