allocator.hpp

Go to the documentation of this file.

//=======================================================================
// Copyright (c) 2014-2023 Baptiste Wicht
// Distributed under the terms of the MIT License.
// (See accompanying file LICENSE or copy at
//  http://opensource.org/licenses/MIT)
//=======================================================================

#pragma once

namespace etl {
/*
 * GCC mangling of vector types (__m128, __m256, ...) is terribly
 * broken. To avoid this, the chosen solution is to use special
 * functions for allocations of these types
 */

template <size_t T>
struct mangling_faker {};

template <typename T>
concept is_mangle_able = std::same_as<std::decay_t<T>, float> || std::same_as<std::decay_t<T>, double>
                                || cpp::specialization_of<std::complex, T> || cpp::specialization_of<etl::complex, T>;

template <size_t A>
struct aligned_allocator {
    template <typename T, size_t S = sizeof(T)>
    static T* allocate(size_t size, mangling_faker<S> /*unused*/ = mangling_faker<S>()) {
        auto required_bytes = sizeof(T) * size;
        auto offset         = (A - 1) + sizeof(uintptr_t);
        auto orig           = malloc(required_bytes + offset);

        if (!orig) {
            return nullptr;
        }

        auto aligned = reinterpret_cast<void**>((reinterpret_cast<size_t>(orig) + offset) & ~(A - 1));
        aligned[-1]  = orig;
        return reinterpret_cast<T*>(aligned);
    }

    template <typename T, size_t S = sizeof(T)>
    static void release(T* ptr, mangling_faker<S> /*unused*/ = mangling_faker<S>()) {
        //Note the const_cast is only to allow compilation
        free((reinterpret_cast<void**>(const_cast<std::remove_const_t<T>*>(ptr)))[-1]);
    }
};

template <typename T, size_t S = sizeof(T)>
auto allocate(size_t size, mangling_faker<S> /*unused*/ = mangling_faker<S>()) {
    static_assert(is_mangle_able<T>, "allocate does not work with vector types");
    return std::make_unique<T[]>(size);
}

template <typename T, size_t S = sizeof(T)>
T* aligned_allocate(size_t size, mangling_faker<S> /*unused*/ = mangling_faker<S>()) {
    return aligned_allocator<32>::allocate<T>(size);
}

template <typename T, size_t S = sizeof(T)>
void aligned_release(T* ptr, mangling_faker<S> /*unused*/ = mangling_faker<S>()) {
    return aligned_allocator<32>::release<T>(ptr);
}

template <typename T, size_t S = sizeof(T)>
struct aligned_ptr {
    T* ptr; 

    explicit aligned_ptr(T* ptr) : ptr(ptr) {}

    aligned_ptr(const aligned_ptr& rhs) = delete;
    aligned_ptr& operator=(const aligned_ptr& rhs) = delete;

    aligned_ptr(aligned_ptr&& rhs) noexcept : ptr(rhs.ptr) {
        rhs.ptr = nullptr;
    }

    aligned_ptr& operator=(aligned_ptr&& rhs) noexcept {
        if (this != &rhs) {
            ptr     = rhs.ptr;
            rhs.ptr = nullptr;
        }

        return *this;
    }

    inline T& operator[](size_t i) {
        return ptr[i];
    }

    inline const T& operator[](size_t i) const {
        return ptr[i];
    }

    ~aligned_ptr() {
        if (ptr) {
            aligned_release(ptr);
        }
    }

    T* get() {
        return ptr;
    }
};

template <typename T, size_t S = sizeof(T)>
aligned_ptr<T> aligned_allocate_auto(size_t size, mangling_faker<S> /*unused*/ = mangling_faker<S>()) {
    return aligned_ptr<T>{aligned_allocate<T>(size)};
}

} //end of namespace etl