Question

在下面的代码中，每10个int的许多向量构造有60％的几率，或者现有的向量被删除，有40％的几率。因此，会有很多调用new / malloc和delete。由于所有这些向量都是vector<int>类型，自定义分配器可以帮助减少对new和delete的调用，从而提高性能吗？这个想法是删除的矢量的空间可以由新构造的空间重用。这样的分配器怎么样？

注意：此问题与分配器有关，可减少对new和delete的呼叫。

#include <iostream>
#include <vector>
#include <random>

using namespace std;

int main() 
{
    // Random generator and distribution
    mt19937 gen(123456);
    uniform_real_distribution<> dis01(0., 1.);

    // Make or delete 10E6 vectors.
    vector< vector<int> > v; //the inner vectors will make many calls to new and delete

    v.reserve(10E5); //assume some size.

    for(int i=0; i<10E6; ++i)
    {
        if(dis01(gen)<0.6) // if true: make new sub-vector
        {
            v.emplace_back(); //new sub-vector
            v.back().reserve(10);

            for(int k=0; k<10; ++k)
                v.back().emplace_back(k); //fill it with some numbers
        }
        else // else, delete the last entry if there is one.
            if(!v.empty())
                v.pop_back();
    }

    cout<<"v.size()= "<<v.size();       
    return 0;
}

Answer 1

你可以通过编写一个分配器来更有效地重用最近释放的内存来获得一些性能，特别是如果所有的向量都是10大小的话。当然，如果是这样，那你就是＆＃39 ;通过使用固定大小的对象获得更多性能。如果向量的分配大小需要是动态的，那么您的问题就像一般的内存分配一样抽象，并且您不太可能改进标准分配器。

除非您能够利用适用于您的具体案例但不是更一般情况的信息，否则您完全不可能提高STL的绩效。

更好的解决方案是不删除矢量对象，而只是将它们保留在矢量＆gt;中，维护一个迭代器/指向＆＃34; end＆＃34;向量（递减而不是删除），然后而不是放置一个元素（构造一个向量），你只需要推进你的迭代器，测试.end()，然后在需要时进行处理，否则重用旧的向量。这假定您的程序不依赖于构造函数或析构函数的副作用（向量没有，但您并没有告诉我们您的实际用例）。

Answer 2

据我所知，https://en.wikipedia.org/wiki/Allocator_(C%2B%2B)，C ++分配器减少了对特定容器的分配和释放请求。我认为这意味着创建和删除容器仍然需要调用new和delete。

您可能需要查看https://github.com/gperftools/gperftools。它是malloc的替代品。它声称在小对象分配方面有所改进，特别是在多线程程序中。

Answer 3

这适用于C ++ 11。较旧的标准需要额外的东西在分配器[1]中实现。

这是概念验证代码。它运行并解决了这个例子问题但受到一些限制。它仍然演示了如何使用自定义分配器来改进在很多std::vector s的情况下的性能创造和破坏。

PoolAlloc.hh：

template<typename T>
struct MemChunk
{
    std::size_t buf_size=0;
    T* buf=nullptr;
    T* top=nullptr;
    std::size_t used=0;
};

template<typename T>
class PoolAllocator
{
    public:
    using value_type=T;

    PoolAllocator();
    explicit PoolAllocator(std::size_t);
    PoolAllocator(PoolAllocator const&) noexcept;
    template<typename U>
        PoolAllocator(PoolAllocator<U> const&) noexcept;
    PoolAllocator(PoolAllocator&&) noexcept;
    PoolAllocator& operator=(PoolAllocator const&)=delete;
    PoolAllocator& operator=(PoolAllocator&&)=delete;
    ~PoolAllocator();

    template <typename U> 
    struct rebind 
    {
        using other=PoolAllocator<U>;
    };

    T* allocate(std::size_t);
    void deallocate(T*, std::size_t) noexcept;

    template<typename U1, typename U2>
        friend bool operator==(PoolAllocator<U1> const&, PoolAllocator<U2> const&) noexcept;

    private:
    std::vector<MemChunk<T>>* memory_=nullptr;
    int* ref_count_=nullptr;
    std::size_t default_buf_size_=0;
};

template<typename T>
PoolAllocator<T>::PoolAllocator():
    PoolAllocator{100000} {}

template<typename T>
PoolAllocator<T>::PoolAllocator(std::size_t buf_size):
    memory_{new std::vector<MemChunk<T>>},
    ref_count_{new int(0)},
    default_buf_size_{buf_size}
{
    memory_->emplace_back();
    memory_->back().buf_size=buf_size;
    memory_->back().buf=new T[buf_size];
    memory_->back().top=memory_->back().buf;
    ++(*ref_count_);
}

template<typename T>
PoolAllocator<T>::PoolAllocator(PoolAllocator const& src) noexcept:
    memory_{src.memory_},
    ref_count_{src.ref_count_},
    default_buf_size_{src.default_buf_size_}
{
    ++(*ref_count_);
}

template<typename T>
PoolAllocator<T>::PoolAllocator(PoolAllocator&& src) noexcept:
    memory_{src.memory_},
    ref_count_{src.ref_count_},
    default_buf_size_{src.default_buf_size_}
{
    src.memory_=nullptr;
    src.ref_count_=nullptr;
}

template<typename T>
template<typename U>
PoolAllocator<T>::PoolAllocator(PoolAllocator<U> const& src) noexcept:
    memory_{src.memory_},
    ref_count_{src.ref_count_},
    default_buf_size_{src.default_buf_size_}
{
    ++(*ref_count_);
}

template<typename T>
PoolAllocator<T>::~PoolAllocator()
{
    if (ref_count_!=nullptr)
    {
        --(*ref_count_);
        if (*ref_count_==0)
        {
            if (memory_!=nullptr)
            {
                for (auto& it : *memory_)
                {
                    delete[] it.buf;
                }
                delete memory_;
            }
            delete ref_count_;
        }
    }
}

template<typename T>
T* 
PoolAllocator<T>::allocate(std::size_t n)
{
    MemChunk<T>* mem_chunk=&memory_->back();
    if ((mem_chunk->used+n)>mem_chunk->buf_size)
    {
        default_buf_size_*=2;
        memory_->emplace_back();
        mem_chunk=&memory_->back();
        std::size_t buf_size=default_buf_size_;
        if (n>default_buf_size_)
        {
            buf_size=n;
        }
        mem_chunk->buf_size=buf_size;
        mem_chunk->buf=new T[mem_chunk->buf_size];
        mem_chunk->top=mem_chunk->buf;
    }
    T* r=mem_chunk->top;
    mem_chunk->top+=n;
    mem_chunk->used+=n;
    return r;
}

template<typename T>
void 
PoolAllocator<T>::deallocate(T* addr, std::size_t n) noexcept
{
    MemChunk<T>* mem_chunk=&memory_->back();
    if (mem_chunk->used>n and (mem_chunk->top-n)==addr)
    {
        mem_chunk->used-=n;
        mem_chunk->top-=n;
    }
}

template<typename U1, typename U2>
bool operator==(PoolAllocator<U1> const& lhs, PoolAllocator<U2> const& rhs) noexcept
{
    return (std::is_same<U1, U2>::value and lhs.memory_==rhs.memory_);
}

使用以下方式修改的示例：

#include <iostream>
#include <vector>
#include <random>   
#include "PoolAlloc.hh"

using namespace std;

int main() 
{
    // Random generator and distribution
    mt19937 gen(123456);
    uniform_real_distribution<> dis01(0., 1.);
    PoolAllocator<int> palloc{1000000};

    // Make or delete 10E6 vectors.
    vector< vector<int, PoolAllocator<int>> > v; //the inner vectors will make many calls to new and delete

    v.reserve(10E5); //assume some size.

    for(int i=0; i<10E6; ++i)
    {
        if(dis01(gen)<0.6) // if true: make new sub-vector
        {
            v.emplace_back(palloc); //new sub-vector
            v.back().reserve(10);

            for(int k=0; k<10; ++k)
                v.back().emplace_back(k); //fill it with some numbers
        }
        else // else, delete the last entry if there is one.
            if(!v.empty())
                v.pop_back();
    }

    cout<<"v.size()= "<<v.size();   
    return 0;
}

malloc的通话次数从~6e6降至21 指令数从3.7e9下降到2.5e9（使用-O3，用valgrind --tool=callgrind测量。

有一些实施细节会影响到在不同的使用情况下的表现。

目前使用多个缓冲区。如果一个满了，另一个满了被建造。这种方式永远不必重新分配操作会让你进入一个受伤的世界（见注释）。

最大的问题是，如何处理解除分配的内存。目前使用的是一种简单的方法，只能进行解除分配内存可用于稍后在它结束时分配缓冲。对于你的例子就足够了，就像你一样在缓冲区的末尾释放内存。

对于更复杂的场景，您需要更复杂的场景机制。存储地址需要一些数据结构和可用内存块的大小。多个概念是可能的在这里，他们的表现会因具体情况而有所不同它们被用于。我怀疑有一个很好的一刀切解决方案。

[1] http://howardhinnant.github.io/stack_alloc.html

Answer 4

自定义分配器可能会解决一些问题，但它不是灵丹妙药。这个例子不足以知道最佳解决方案是什么。我会建议一些不同的东西，不是因为它更好，而是因为它在某些情况下会更好。

v.resize(10E5, std::vector<int>(10));

而不是

v.reserve(10E5);

但是你需要一个迭代器来为向量上的下一个空闲插槽和所有好东西。

Answer 5

您是否尝试过现有的boost pool分配器？

http://theboostcpplibraries.com/boost.pool

我认为，如果要重用“std :: vector的对象本身”内存，它应该与创置/创建池有些相关。

Answer 6

我看到它的方式，当您确切知道内存的使用方式时，自定义分配器实际上只能提供优于标准分配器的优势。通常，您正在进行大小/性能折衷，自定义分配器允许您控制此决策。

如果在您的示例中，您可以为每个列表使用页面大小块，那么您可以保留一个免费的页面列表，并将其分配给所有将来的分配。如果你在每个列表中只有十个整数，那么这会产生很大的内存开销，但如果列表较大则可能是一个很大的胜利，并且可以在没有调用new或者删除每个int的情况下完成。这实质上是为每个列表创建一个固定大小的内存池。完成列表后，您只需将页面放回到空闲列表中，然后将其用于下一个列表。

如果许多vector <t>被构造和销毁，自定义分配器是否会提高性能？

6 个答案: