AlignedStorage.h

Go to the documentation of this file.

#pragma once
 
 
#include "common/Assert.h"
#include "common/Traits.h"
#include <mm_malloc.h>
 
NAMESPACE_SPH_BEGIN
 
template <typename T, typename... TArgs>
INLINE T* alignedNew(TArgs&&... args) {
    constexpr Size size = sizeof(T);
    constexpr Size alignment = alignof(T);
    void* ptr = _mm_malloc(size, alignment);
    SPH_ASSERT(ptr);
    return new (ptr) T(std::forward<TArgs>(args)...);
}
 
template <typename T>
INLINE void alignedDelete(T* ptr) {
    if (!ptr) {
        return;
    }
 
    ptr->~T();
    _mm_free(ptr);
    ptr = nullptr;
}
 
template <typename T>
INLINE bool isAligned(const T& value) {
    return reinterpret_cast<std::size_t>(std::addressof(value)) % alignof(T) == 0;
}
 
 
 
// dereferencing type-punned pointer will break strict-aliasing rules
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
 
template <typename Type>
class AlignedStorage {
private:
    struct __attribute__((__may_alias__)) Holder {
        alignas(Type) char storage[sizeof(Type)];
    } holder;
 
public:
    AlignedStorage() = default;
 
    template <typename... TArgs>
    INLINE void emplace(TArgs&&... rest) {
        new (&holder) Type(std::forward<TArgs>(rest)...);
    }
 
    INLINE void destroy() {
        get().~Type();
    }
 
    INLINE constexpr operator Type&() noexcept {
        return get();
    }
 
    INLINE constexpr operator const Type&() const noexcept {
        return get();
    }
 
    INLINE constexpr Type& get() noexcept {
        return reinterpret_cast<Type&>(holder);
    }
 
    INLINE constexpr const Type& get() const noexcept {
        return reinterpret_cast<const Type&>(holder);
    }
};
 
template <typename Type>
class AlignedStorage<Type&> {
    using StorageType = ReferenceWrapper<Type>;
 
    StorageType storage;
 
public:
    AlignedStorage() = default;
 
    template <typename T>
    INLINE void emplace(T& ref) {
        storage = StorageType(ref);
    }
 
    // no need do explicitly destroy reference wrapper
    INLINE void destroy() {}
 
    INLINE constexpr operator Type&() noexcept {
        return get();
    }
 
    INLINE constexpr operator const Type&() const noexcept {
        return get();
    }
 
    INLINE constexpr Type& get() noexcept {
        return storage;
    }
 
    INLINE constexpr const Type& get() const noexcept {
        return storage;
    }
};
 
 
NAMESPACE_SPH_END