Как найти память, буст по BIMAP

Question

У меня есть boost bimap

#include <iostream>
#include <utility>
#include <boost/bimap.hpp>
#include <boost/bimap/set_of.hpp>
#include <boost/bimap/multiset_of.hpp>

namespace bimaps = boost::bimaps;
typedef boost::bimap<bimaps::set_of<unsigned long long int>,
        bimaps::multiset_of<unsigned long long int > > bimap_reference;
typedef bimap_reference::value_type position;
bimap_reference numbers;

int main()
{
    numbers.insert(position(12345689, 1000000000));
    numbers.insert(position(23456789, 8000000000));   
    return 0;
}

У меня около 180000000 записей. Теоретически это должно занять ~2,7 ГБ пространства (180000000*8*2 = 2880000000 байт = 2880000000/ 1024*1024*1024 = ~2,7 ГБ). Теперь я хочу найти фактическое место, занимаемое boost bimap, Как мне это сделать.

Answer 1

Как и комментарии под вашим вопросом, вы можете перегрузить new а также delete операторы для отслеживания выделения памяти и освобождения. Пример в разделе " Глобальные замены " этой статьи показывает очень простой пример:

void* operator new(std::size_t sz) {
    std::printf("global op new called, size = %zu\n", sz);
    return std::malloc(sz);
}
void operator delete(void* ptr) noexcept {
    std::puts("global op delete called");
    std::free(ptr);
}

Единственная проблема этого примера в том, что вы не можете определить, сколько памяти освобождено. Чтобы решить эту проблему, ознакомьтесь с принятым ответом на вопрос " Как отслеживать распределение памяти в C++ (особенно новый / удалить)".

Пример внутри упомянутого ответа использует std::map с пользовательским распределителем для хранения адресов и размеров выделенных блоков памяти. Внутри delete оператор перегрузки удаляет элементы с указанными адресами. Почти без изменений он может быть использован в соответствии с вашими требованиями:

#include <map>

template<typename T>
struct MemoryMapAllocator : std::allocator<T> {
    typedef typename std::allocator<T>::pointer pointer;
    typedef typename std::allocator<T>::size_type size_type;
    template<typename U> struct rebind { typedef MemoryMapAllocator<U> other; };

    MemoryMapAllocator() {}

    template<typename U>
    MemoryMapAllocator(const MemoryMapAllocator<U>& u) : std::allocator<T>(u) {}

    pointer allocate(size_type size, std::allocator<void>::const_pointer = 0) {
        void* p = std::malloc(size * sizeof(T));
        if(p == 0)
            throw std::bad_alloc();
        return static_cast<pointer>(p);
    }
    void deallocate(pointer p, size_type) {
        std::free(p);
    }
};

typedef std::map<void*, std::size_t, std::less<void*>,
            MemoryMapAllocator<std::pair<void* const, std::size_t>>> MemoryMap;

MemoryMap& getMemoryMap() {
    static MemoryMap memMap;
    return memMap;
}

std::size_t totalAllocatedMemory() {
    std::size_t sum = 0;
    for(auto& e : getMemoryMap())
        sum += e.second;
    return sum;
}

void* operator new(std::size_t size) {
    void* mem = std::malloc(size == 0 ? 1 : size);

    if(mem == 0)
        throw std::bad_alloc();

    getMemoryMap()[mem] = size;
    return mem;
}

void operator delete(void* mem) {
    getMemoryMap().erase(mem);
    std::free(mem);
}

Live Demo