memalloc.hpp

Go to the documentation of this file.

/* 
 * This file is part of PLaSK (https://plask.app) by Photonics Group at TUL
 * Copyright (c) 2022 Lodz University of Technology
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 */
#ifndef PLASK__MEMALLOC_H
#define PLASK__MEMALLOC_H
 
#include <cstdlib>
#include <memory>
 
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
#include <malloc.h>
#endif
 
#include <utility>
#include <limits>
#include <new>
 
namespace plask {
 
#if (defined(__GLIBC__) && ((__GLIBC__>=2 && __GLIBC_MINOR__ >= 8) || __GLIBC__>2) && defined(__LP64__)) || \
    defined(__APPLE__) || defined(_WIN64) || (defined(__FreeBSD__) && !defined(__arm__) && !defined(__mips__))
#   define PLASK_MALLOC_ALIGNED 1
#else
#   define PLASK_MALLOC_ALIGNED 0
#endif
 
 
#if !PLASK_MALLOC_ALIGNED && !defined(_MSC_VER)
namespace detail {
 
    inline void* custom_aligned_malloc(std::size_t size)
    {
        void *original = std::malloc(size+16);
        if (original == 0) return 0;
        void *aligned = reinterpret_cast<void*>((reinterpret_cast<size_t>(original) & ~(size_t(15))) + 16);
        *(reinterpret_cast<void**>(aligned) - 1) = original;
        return aligned;
    }
 
    inline void custom_aligned_free(void *ptr)
    {
        if (ptr) std::free(*(reinterpret_cast<void**>(ptr) - 1));
    }
 
    inline void* custom_aligned_realloc(void* ptr, std::size_t size, std::size_t=0)
    {
        if (ptr == 0) return custom_aligned_malloc(size);
        void *original = *(reinterpret_cast<void**>(ptr) - 1);
        original = std::realloc(original,size+16);
        if (original == 0) return 0;
        void *aligned = reinterpret_cast<void*>((reinterpret_cast<size_t>(original) & ~(size_t(15))) + 16);
        *(reinterpret_cast<void**>(aligned) - 1) = original;
        return aligned;
    }
 
}
#endif
 
inline void* aligned_malloc(std::size_t size)
{
    void *result;
#if PLASK_MALLOC_ALIGNED
    result = std::malloc(size);
#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
    result = _aligned_malloc(size, 16);
#else
    result = detail::custom_aligned_malloc(size);
#endif
    if(!result && size) throw std::bad_alloc();
    return result;
}
 
inline void aligned_free(void *ptr)
{
    if (!ptr) return;
#if PLASK_MALLOC_ALIGNED
    std::free(ptr);
#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
    _aligned_free(ptr);
#else
    detail::custom_aligned_free(ptr);
#endif
}
 
inline void* aligned_realloc(void *ptr, std::size_t new_size, std::size_t old_size=0)
{
    (void) old_size;    // don't warn about unused old_size
    void *result;
#if PLASK_MALLOC_ALIGNED
    result = std::realloc(ptr,new_size);
#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
    result = _aligned_realloc(ptr,new_size,16);
#else
    result = detail::custom_aligned_realloc(ptr,new_size,old_size);
#endif
    if (!result && new_size) throw std::bad_alloc();
    return result;
}
 
template <typename T>
inline T* aligned_malloc(std::size_t num=1) {
    T* mem = reinterpret_cast<T*>(aligned_malloc(num * sizeof(T)));
    return mem;
}
 
template <typename T>
inline void aligned_free(T* ptr) {
    aligned_free(reinterpret_cast<void*>(const_cast<typename std::remove_const<T>::type*>(ptr)));
}
 
template <typename T>
struct aligned_deleter {
    constexpr aligned_deleter() noexcept = default;
    template<typename U, typename=typename std::enable_if<std::is_convertible<U*,T*>::value>::type>
        aligned_deleter(const aligned_deleter<U>&) noexcept {}
 
    void operator()(T* ptr) const {
        aligned_free<T>(ptr);
    }
};
 
template< class T > struct aligned_deleter<T[]> {
    void operator()(T* ptr) const {
        aligned_free<T>(ptr);
    }
};
 
template <typename T>
using aligned_unique_ptr = std::unique_ptr<T, aligned_deleter<T>>;
 
template <typename T, typename... Args>
inline T* aligned_new(Args&&... args) {
    T* mem = reinterpret_cast<T*>(aligned_malloc(sizeof(T)));
    new(mem) T(std::forward<Args>(args)...);
    return mem;
}
 
template <typename T>
inline void aligned_delete(T* ptr) {
    ptr->~T();
    aligned_free(ptr);
}
 
template <typename T, typename... Args>
inline T* aligned_new_array(std::size_t num, Args&&... args) {
    T* mem = reinterpret_cast<T*>(aligned_malloc(num * sizeof(T)));
    for (size_t i = 0; i != num; ++i) new(mem+i) T(std::forward<Args>(args)...);
    return mem;
}
 
template <typename T>
inline void aligned_delete_array(std::size_t num, T* ptr) {
    while (num)
        ptr[--num].~T();
    aligned_free(ptr);
}
 
template<class T>
struct aligned_allocator {
 
    typedef std::size_t     size_type;
    typedef std::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 aligned_allocator<U> other; };
 
    pointer address(reference value) const { return &value; }
 
    const_pointer address(const_reference value) const { return &value; }
 
    aligned_allocator() {}
 
    aligned_allocator(const aligned_allocator&) {}
 
    template<class U>
    aligned_allocator(const aligned_allocator<U>&) {}
 
    ~aligned_allocator(){}
 
    size_type max_size() const { return (std::numeric_limits<size_type>::max)(); }
 
    pointer allocate(size_type num) { return aligned_malloc<T>(num); }
 
    void construct(pointer p, const T& value) { new(p) T(value); }
 
    template<typename... Args>
    void  construct(pointer p, Args&&... args) { new(p) T(std::forward<Args>(args)...); }
 
    void destroy(pointer p) { p->~T(); }
 
    void deallocate(pointer p, size_type) { aligned_free(p); }
 
    bool operator!=(const aligned_allocator<T>&) const { return false; }
 
    bool operator==(const aligned_allocator<T>&) const { return true; }
};
 
 
 
} // namespace plask
 
 
#endif // PLASK__MEMALLOC_H