MRHeapBytes.h

Go to the documentation of this file.

#pragma once
 
#include "MRMeshFwd.h"
#include <vector>
#include <memory>
 
namespace MR
{
 
 
template<typename T>
[[nodiscard]] inline size_t heapBytes( const std::vector<T> & vec )
{
    constexpr bool hasHeapBytes = requires( const T& t ) { t.heapBytes(); };
    if constexpr ( hasHeapBytes )
    {
        size_t res = vec.capacity() * sizeof( T );
        for ( const T & t : vec )
            res += t.heapBytes();
        return res;
    }
    else
    {
        return vec.capacity() * sizeof( T );
    }
}
 
template<typename T, typename U>
[[nodiscard]] inline size_t heapBytes( const Vector<T, U>& vec )
{
    constexpr bool hasHeapBytes = requires( const T & t ) { t.heapBytes(); };
    if constexpr ( hasHeapBytes )
    {
        size_t res = vec.size() * sizeof( T );
        for ( const T & t : vec )
            res += t.heapBytes();
        return res;
    }
    else
    {
        return vec.size() * sizeof( T );
    }
}
 
template<typename T>
[[nodiscard]] inline size_t heapBytes( const std::unique_ptr<T> & ptr )
{
    if ( !ptr )
        return 0;
    return sizeof( T ) + ptr->heapBytes();
}
 
template<typename T>
[[nodiscard]] inline size_t heapBytes( const std::shared_ptr<T> & ptr )
{
    if ( !ptr )
        return 0;
    return sizeof( T ) + ptr->heapBytes();
}
 
template<typename T>
[[nodiscard]] inline size_t heapBytes( const std::function<T> & )
{
    return 0;
}
 
template<typename ...Ts>
[[nodiscard]] inline size_t heapBytes( const phmap::flat_hash_map<Ts...>& hashMap )
{
    // from parallel_hashmap/phmap.h:
    // The control state and slot array are stored contiguously in a shared heap
    // allocation. The layout of this allocation is: `capacity()` control bytes,
    // one sentinel control byte, `Group::kWidth - 1` cloned control bytes,
    // <possible padding>, `capacity()` slots
    const auto cap = hashMap.capacity();
    constexpr size_t kWidth = 16; // the usage of phmap::priv::Group::kWidth here will require inclusion of phmap.h
    return cap + kWidth + cap * sizeof( typename phmap::flat_hash_map<Ts...>::slot_type );
}
 
 
} // namespace MR