Как уменьшить потребление памяти unordered_multiset?

Question

Я использовал unordered_multiset в своем коде по следующим двум причинам:

1. Должно быть легко найти или посмотреть данные.
2. Должен поддерживать загрузку повторяющихся значений.

unordered_multiset, как правило, намного быстрее, чем multisets & vector, как для вставки, так и для поиска, а иногда даже для удаления.

Но плохо то, что это занимает слишком много памяти.

Я хранил значения без знака __int64 (8 байт) в unordered_multiset и правильно очищаю значения из unordered_multiset. Кто-нибудь может объяснить, почему он занимает память и как решить это потребление памяти?

Answer 1

У Caleth есть хорошее предложение, или вы можете посмотреть на использование памяти внутри процессов.

перед тем как вставить в мультимножество и после.

Скорее всего конечно разница, загружена огромная dll.

Answer 2

Вы можете получить намного лучшее измерение того, сколько места std::Контейнер использует, предоставляя ему специальный распределитель, который регистрирует, сколько его просят выделить.

например

std::size_t total_allocation = 0;

template< class T >
struct logging_allocator
{   
    using value_type = T;
    using pointer = T*;
    using const_pointer = const T*;
    using reference = T&;
    using const_reference = const T&;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using propagate_on_container_move_assignment = std::true_type;
    template< class U > struct rebind { using other = logging_allocator<U>; };
    using is_always_equal = std::true_type;

    pointer address( reference x ) const { return base.address(x); }
    const_pointer address( const_reference x ) const{ return base.address(x); }

    pointer allocate( size_type n, const_pointer hint = nullptr ){ 
        total_allocation += n; 
        return base.allocate(n, hint); 
    }
    pointer allocate( size_type n, const void * hint){ 
        total_allocation += n; 
        return base.allocate(n, hint); 
    }
    pointer allocate( size_type n ){ 
        total_allocation += n; 
        return base.allocate(n, hint); 
    }

    void deallocate( T* p, size_type n ) {
        total_allocation -= n; 
        return base.deallocate(p, n);
    }

    size_type max_size() const {
        return base.max_size();
    }

    void construct( pointer p, const_reference val ) {
        total_allocation += sizeof(T); 
        return base.construct(p, val);
    }
    template< class U, class... Args >
    void construct( U* p, Args&&... args ) {
        total_allocation += sizeof(U); 
        return base.construct(p, args...);
    }

    void destroy( pointer p ) {
        total_allocation -= sizeof(T); 
        return base.destroy(p);
    }
    template< class U >
    void destroy( U* p ) {
        total_allocation -= sizeof(U); 
        return base.destroy(p);
    }

private:
    std::allocator<T> base;
}