memory.hpp

// Copyright Take Vos 2019-2021.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "required.hpp"
#include "assert.hpp"
#include <concepts>
#include <memory>
#include <vector>
#include <map>
#include <unordered_map>
#include <type_traits>
#include <string.h>
 
namespace hi::inline v1 {
 
[[nodiscard]] bool equal_ptr(auto *p1, auto *p2) noexcept
{
    return static_cast<void *>(p1) == static_cast<void *>(p2);
}
 
template<typename T, typename U>
void memswap(T& dst, U& src)
{
    static_assert(sizeof(T) == sizeof(U), "memswap requires both objects of equal size");
    std::byte tmp[sizeof(T)];
    memcpy(tmp, &src, sizeof(T));
    memcpy(&src, &dst, sizeof(U));
    memcpy(&dst, tmp, sizeof(T));
}
 
template<typename InputIt, typename T>
T *placement_copy(InputIt src, T *dst)
{
    hi_axiom(dst != nullptr);
    return new (dst) T(*src);
}
 
template<typename InputIt, typename T>
void placement_copy(InputIt src_first, InputIt src_last, T *dst_first)
{
    hi_axiom(src_first != dst_first);
    hi_axiom(src_last >= src_first);
 
    auto src = src_first;
    auto dst = dst_first;
    while (src != src_last) {
        placement_copy(src++, dst++);
    }
}
 
template<typename T>
T *placement_move(T *src, T *dst)
{
    hi_axiom(src != nullptr);
    hi_axiom(dst != nullptr);
 
    auto dst_ = new (dst) T(std::move(*src));
    std::destroy_at(src);
    return dst_;
}
 
template<typename T>
void placement_move_within_array(T *src_first, T *src_last, T *dst_first)
{
    hi_axiom(src_last >= src_first);
 
    if (src_first < dst_first) {
        auto dst_last = dst_first + (src_last - src_first);
 
        auto src = src_last;
        auto dst = dst_last;
        while (src != src_first) {
            placement_move(--src, --dst);
        }
 
    } else if (src_first > dst_first) {
        auto src = src_first;
        auto dst = dst_first;
        while (src != src_last) {
            placement_move(src++, dst++);
        }
 
    } else {
        // When src_first and dst_first are equal then no movement is necessary.
        ;
    }
}
 
template<typename T>
void placement_move(T *src, T *src_last, T *dst)
{
    hi_axiom(src_last >= src);
 
    while (src != src_last) {
        placement_move(src++, dst++);
    }
}
 
template<typename It, typename... Args>
void construct(It first, It last, Args const&...args)
{
    for (auto it = first; it != last; ++it) {
        std::construct_at(std::addressof(*it), args...);
    }
}
 
template<typename T>
constexpr bool is_aligned(T *p)
{
    return (reinterpret_cast<ptrdiff_t>(p) % std::alignment_of<T>::value) == 0;
}
 
template<std::unsigned_integral T>
constexpr T floor(T value, T alignment) noexcept
{
    return (value / alignment) * alignment;
}
 
template<std::unsigned_integral T>
constexpr T ceil(T value, T alignment) noexcept
{
    return floor(value + (alignment - 1), alignment);
}
 
template<typename T>
constexpr T *ceil(T *ptr, std::size_t alignment) noexcept
{
    hilet aligned_byte_offset = ceil(reinterpret_cast<uintptr_t>(ptr), static_cast<uintptr_t>(alignment));
    return reinterpret_cast<T *>(aligned_byte_offset);
}
 
template<typename T>
constexpr T *floor(T *ptr, std::size_t alignment) noexcept
{
    hilet aligned_byte_offset = floor(reinterpret_cast<uintptr_t>(ptr), static_cast<uintptr_t>(alignment));
    return reinterpret_cast<T *>(aligned_byte_offset);
}
 
template<typename T>
inline void cleanupWeakPointers(std::vector<std::weak_ptr<T>>& v) noexcept
{
    auto i = v.begin();
    while (i != v.end()) {
        if (i->expired()) {
            i = v.erase(i);
        } else {
            i++;
        }
    }
}
 
template<typename K, typename T>
inline void cleanupWeakPointers(std::unordered_map<K, std::weak_ptr<T>>& v) noexcept
{
    auto i = v.begin();
    while (i != v.end()) {
        if (i->second.expired()) {
            i = v.erase(i);
        } else {
            i++;
        }
    }
}
 
template<typename K, typename T>
inline void cleanupWeakPointers(std::unordered_map<K, std::vector<std::weak_ptr<T>>>& v) noexcept
{
    auto i = v.begin();
    while (i != v.end()) {
        cleanupWeakPointers(i->second);
        if (i->second.size() == 0) {
            i = v.erase(i);
        } else {
            i++;
        }
    }
}
 
template<typename Value, typename Map, typename Key, typename... Args>
inline std::shared_ptr<Value> try_make_shared(Map& map, Key key, Args... args)
{
    std::shared_ptr<Value> value;
 
    hilet i = map.find(key);
    if (i == map.end()) {
        value = std::make_shared<Value>(std::forward<Args>(args)...);
        map.insert_or_assign(key, value);
    } else {
        value = i->second;
    }
    return value;
}
 
inline uint64_t ptr_to_uint48(auto *ptr) noexcept
{
    hi_axiom(static_cast<uint64_t>(ptr) % 16 == 0);
 
    if constexpr (processor::current == processor::x64) {
        // Only the bottom 48 bits are needed.
        hi_axiom(
            (static_cast<uint64_t>(ptr) & 0xffff'8000'0000'0000) == 0 ||
            (static_cast<uint64_t>(ptr) & 0xffff'8000'0000'0000) == 0xffff'8000'0000'0000);
        return (static_cast<uint64_t>(ptr) << 16) >> 16;
 
    } else if constexpr (processor::current == processor::arm) {
        // The top 8 bits may contain a tag.
        hi_axiom(
            (static_cast<uint64_t>(ptr) & 0x00ff'8000'0000'0000) == 0 ||
            (static_cast<uint64_t>(ptr) & 0x00ff'8000'0000'0000) == 0x00ff'8000'0000'0000);
 
        // Take the 4 sign bits + 44 msb bits of address.
        auto u64 = (static_cast<uint64_t>(ptr) << 12) >> 16;
 
        // Extract the 4 bit key.
        auto key = (static_cast<uint64_t>(ptr) >> 56) << 44;
 
        // XOR the key with the sign bits in the upper part of the 48 bit result.
        return key ^ u64;
 
    } else {
        hi_static_no_default();
    }
}
 
template<typename T>
T *uint48_to_ptr(uint64_t x) noexcept
{
    hi_axiom((x >> 48) == 0);
 
    if constexpr (processor::current == processor::x64) {
        // Shift the upper bits away and sign extend the upper 16 bits.
        auto i64 = (static_cast<int64_t>(x) << 16) >> 16;
        return reinterpret_cast<T *>(i64);
 
    } else if constexpr (processor::current == processor::arm) {
        // Get 4 bit key (xor-ed with the sign bits).
        auto key = (static_cast<uint64_t>(x) >> 44) << 56;
 
        // Sign extend the address and make the bottom 4 bits zero.
        auto i64 = (static_cast<int64_t>(x) << 20) >> 16;
 
        // Add the original key by XOR with the sign.
        return reinterpret_cast<T *>(key ^ static_cast<uint64_t>(i64));
 
    } else {
        hi_static_no_default();
    }
}
 
} // namespace hi::inline v1