有比boost::object_pool更快的C++堆分配/取消分配机制吗？

Question

有比boost::object_pool更快的C++堆分配/取消分配机制吗？

5

本周我了解了boost::object_pool，并惊讶地发现它比普通的new和delete快20-30％。

为了测试，我编写了一个小型的C ++应用程序，使用boost :: chrono来计时不同的堆分配器/取消分配器（shared_ptr）。这些函数本身执行简单的60M次迭代循环，使用“new”和“delete”。下面是代码：

#include <iostream>

#include <memory>
using std::shared_ptr;

#include <boost/smart_ptr.hpp>
#include <boost/chrono.hpp>
#include <boost/chrono/chrono_io.hpp>
#include <boost/pool/object_pool.hpp>

#include <SSVUtils/SSVUtils.h>

#include "TestClass.h"

const long lTestRecursion = 60000000L;

void WithSmartPtrs()
{
    boost::chrono::system_clock::time_point startTime = boost::chrono::system_clock::now();
    std::cout << "Start time: " << startTime << std::endl;

    for (long i=0; i < lTestRecursion; ++i)
    {
        boost::shared_ptr<TestClass> spTC = boost::make_shared<TestClass>("Test input data!");  
    }

    boost::chrono::system_clock::time_point endTime = boost::chrono::system_clock::now();
    std::cout << "End time: " << endTime << std::endl;

    boost::chrono::duration<double> d = endTime - startTime;
    std::cout << "Duration: " << d << std::endl;
}

void WithSTDSmartPtrs()
{
    boost::chrono::system_clock::time_point startTime = boost::chrono::system_clock::now();
    std::cout << "Start time: " << startTime << std::endl;

    for (long i=0; i < lTestRecursion; ++i)
    {
        std::shared_ptr<TestClass> spTC = std::make_shared<TestClass>("Test input data!");  
    }

    boost::chrono::system_clock::time_point endTime = boost::chrono::system_clock::now();
    std::cout << "End time: " << endTime << std::endl;

    boost::chrono::duration<double> d = endTime - startTime;
    std::cout << "Duration: " << d << std::endl;
}

template<typename T> struct Deleter {
    void operator()(T *p)
    {
        delete p;
    }
};


void WithSmartPtrsUnique()
{
    boost::chrono::system_clock::time_point startTime = boost::chrono::system_clock::now();
    std::cout << "Start time: " << startTime << std::endl;

    for (long i=0; i < lTestRecursion; ++i)
    {
        boost::unique_ptr<TestClass, Deleter<TestClass> > spTC = boost::unique_ptr<TestClass, Deleter<TestClass> >(new TestClass("Test input data!"));  
    }

    boost::chrono::system_clock::time_point endTime = boost::chrono::system_clock::now();
    std::cout << "End time: " << endTime << std::endl;

    boost::chrono::duration<double> d = endTime - startTime;
    std::cout << "Duration: " << d << std::endl;
}

void WithSmartPtrsNoMakeShared()
{
    boost::chrono::system_clock::time_point startTime = boost::chrono::system_clock::now();
    std::cout << "Start time: " << startTime << std::endl;

    for (long i=0; i < lTestRecursion; ++i)
    {
        boost::shared_ptr<TestClass> spTC = boost::shared_ptr<TestClass>( new TestClass("Test input data!"));   
    }

    boost::chrono::system_clock::time_point endTime = boost::chrono::system_clock::now();
    std::cout << "End time: " << endTime << std::endl;

    boost::chrono::duration<double> d = endTime - startTime;
    std::cout << "Duration: " << d << std::endl;
}


void WithoutSmartPtrs()
{
    boost::chrono::system_clock::time_point startTime = boost::chrono::system_clock::now();
    std::cout << "Start time: " << startTime << std::endl;

    for (long i=0; i < lTestRecursion; ++i)
    {
        TestClass* pTC = new TestClass("Test input data!"); 
        delete pTC;
    }

    boost::chrono::system_clock::time_point endTime = boost::chrono::system_clock::now();
    std::cout << "End time: " << endTime << std::endl;

    boost::chrono::duration<double> d = endTime - startTime;
    std::cout << "Duration: " << d << std::endl;
}

void WithObjectPool()
{
    boost::chrono::system_clock::time_point startTime = boost::chrono::system_clock::now();
    std::cout << "Start time: " << startTime << std::endl;

    {
        boost::object_pool<TestClass> pool;
        for (long i=0; i < lTestRecursion; ++i)
        {
            TestClass* pTC = pool.construct("Test input data!");    
            pool.destroy(pTC);
        }
    }

    boost::chrono::system_clock::time_point endTime = boost::chrono::system_clock::now();
    std::cout << "End time: " << endTime << std::endl;

    boost::chrono::duration<double> d = endTime - startTime;
    std::cout << "Duration: " << d << std::endl;
}


void WithObjectPoolNoDestroy()
{
    boost::chrono::system_clock::time_point startTime = boost::chrono::system_clock::now();
    std::cout << "Start time: " << startTime << std::endl;

    //{
        boost::object_pool<TestClass> pool;
        for (long i=0; i < lTestRecursion; ++i)
        {
            TestClass* pTC = pool.construct("Test input data!");    
            //pool.destroy(pTC);
        }
    //}

    boost::chrono::system_clock::time_point endTime = boost::chrono::system_clock::now();
    std::cout << "End time: " << endTime << std::endl;

    boost::chrono::duration<double> d = endTime - startTime;
    std::cout << "Duration: " << d << std::endl;
}



void WithSSVUtilsPreAllocDyn()
{
    boost::chrono::system_clock::time_point startTime = boost::chrono::system_clock::now();
    std::cout << "Start time: " << startTime << std::endl;

    {
        ssvu::PreAlloc::PreAllocDyn preAllocatorDyn(1024*1024);
        for (long i=0; i < lTestRecursion; ++i)
        {
            TestClass* pTC = preAllocatorDyn.create<TestClass>("Test input data!"); 
            preAllocatorDyn.destroy(pTC);
        }
    }

    boost::chrono::system_clock::time_point endTime = boost::chrono::system_clock::now();
    std::cout << "End time: " << endTime << std::endl;

    boost::chrono::duration<double> d = endTime - startTime;
    std::cout << "Duration: " << d << std::endl;
}



void WithSSVUtilsPreAllocStatic()
{
    boost::chrono::system_clock::time_point startTime = boost::chrono::system_clock::now();
    std::cout << "Start time: " << startTime << std::endl;

    {
        ssvu::PreAlloc::PreAllocStatic<TestClass> preAllocatorStat(10);
        for (long i=0; i < lTestRecursion; ++i)
        {
            TestClass* pTC = preAllocatorStat.create<TestClass>("Test input data!");    
            preAllocatorStat.destroy(pTC);
        }
    }

    boost::chrono::system_clock::time_point endTime = boost::chrono::system_clock::now();
    std::cout << "End time: " << endTime << std::endl;

    boost::chrono::duration<double> d = endTime - startTime;
    std::cout << "Duration: " << d << std::endl;
}


int main()
{
    std::cout << " With OUT smartptrs (new and delete): " << std::endl;
    WithoutSmartPtrs();


    std::cout << std::endl << " With smartptrs (boost::shared_ptr withOUT make_shared): " << std::endl;
    WithSmartPtrsNoMakeShared();

    std::cout << std::endl << " With smartptrs (boost::shared_ptr with make_shared): " << std::endl;
    WithSmartPtrs();

    std::cout << std::endl << " With STD smart_ptr (std::shared_ptr with make_shared): " << std::endl;
    WithSTDSmartPtrs();


    std::cout << std::endl << " With Object Pool (boost::object_pool<>): " << std::endl;
    WithObjectPool();

    std::cout << std::endl << " With Object Pool (boost::object_pool<>) but without destroy called!: " << std::endl;
    WithObjectPoolNoDestroy();


    std::cout << std::endl << " With SSVUtils PreAllocDyn(1024*1024)!: " << std::endl;
    WithSSVUtilsPreAllocDyn();


    std::cout << std::endl << " With SSVUtils PreAllocStatic(10)!: " << std::endl;
    WithSSVUtilsPreAllocStatic();


    return 0;
}

结果：

On Ubuntu LTS 12.04 x64 with GNU C++ 4.6 and boost 1.49                                                                         


No smart ptrs (new/delete)                      5,08024     100     5,1387      100     5,1108      100     5,1099  100


With boost::shared_ptr No boost::make_shared                        7,36128 2,2810  145     7,34522 2,2065  143     7,28801 2,1772  143     7,3315  143

With boost::shared_ptr and boost::make_shared                       6,60351 1,5233  130     6,82849 1,6898  133     6,61059 1,4998  129     6,6809  131

With std::shared_ptr and std::make_shared                       6,07756 0,9973  120     5,93100 0,7923  115     5,9037  0,7929  116     5,9708  117


With boost::unique_ptr                      4,97147 -0,1088 100     5,0428  -0,0959 98      4,96625 -0,1445 97      4,9935  98


With boost::object_pool                     3,53291 -1,5473 70      3,60357 -1,5351 70      3,52986 -1,5809 69      3,5554  70

With boost::object_pool (Without calling Destroy)                       4,52430 -0,5559 89      4,51602 -0,6227 88      4,52137 -0,5894 88      4,5206  88

在我的 MacBook Pro 上使用 SSVUtils PreAllocDyn 的结果：

编译器版本为：

  g++-mp-4.8 -I$BOOSTHOME/include -I$SSVUTILSHOME/include  -std=c++11 -O2 -L$BOOSTHOME/lib -lboost_system -lboost_chrono  -o smartptrtest smartptr.cpp

 With OUT smartptrs (new and delete): 
Start time: 1381596718412786000 nanoseconds since Jan 1, 1970
End time: 1381596731642044000 nanoseconds since Jan 1, 1970
Duration: 13.2293 seconds

 With smartptrs (boost::shared_ptr withOUT make_shared): 
Start time: 1381596731642108000 nanoseconds since Jan 1, 1970
End time: 1381596753651561000 nanoseconds since Jan 1, 1970
Duration: 22.0095 seconds

 With smartptrs (boost::shared_ptr with make_shared): 
Start time: 1381596753651611000 nanoseconds since Jan 1, 1970
End time: 1381596768909452000 nanoseconds since Jan 1, 1970
Duration: 15.2578 seconds

 With STD smart_ptr (std::shared_ptr with make_shared): 
Start time: 1381596768909496000 nanoseconds since Jan 1, 1970
End time: 1381596785500599000 nanoseconds since Jan 1, 1970
Duration: 16.5911 seconds

 With Object Pool (boost::object_pool<>): 
Start time: 1381596785500638000 nanoseconds since Jan 1, 1970
End time: 1381596793484515000 nanoseconds since Jan 1, 1970
Duration: 7.98388 seconds

 With Object Pool (boost::object_pool<>) but without destroy called!: 
Start time: 1381596793484551000 nanoseconds since Jan 1, 1970
End time: 1381596805774318000 nanoseconds since Jan 1, 1970
Duration: 12.2898 seconds

 With SSVUtils PreAllocDyn(1024*1024)!: 
Start time: 1381596815742696000 nanoseconds since Jan 1, 1970
End time: 1381596824173405000 nanoseconds since Jan 1, 1970
Duration: 8.43071 seconds

 With SSVUtils PreAllocStatic(10)!: 
Start time: 1381596824173448000 nanoseconds since Jan 1, 1970
End time: 1381596832034965000 nanoseconds since Jan 1, 1970
Duration: 7.86152 seconds

我的问题是：除了shared_ptr/unique_ptr/boost::object_pool之外，还有哪些堆/分配机制可以用于快速分配/释放大量对象？

注意：我在其他机器和操作系统上也有更多的结果。

编辑1：添加了SSVUtils PreAllocDyn结果编辑4：添加了我的编译器命令行选项，并重新测试了SSVUtils PreAllocStatic(10)

谢谢

- Henry Roeland

1

我在这里创建了一些未记录的资源池链接。你可能正在寻找PreAllocStatic。 - Vittorio Romeo

如果可以避免单个销毁项目，则可能会更快。竞技场分配中的常见模式是：分配竞技场，分配竞技场内的个体，释放竞技场。但是，正式不调用对象的析构函数是未定义行为。 - Matthieu M.

3

如果您正在比较new/delete和boost pool分配器，请确保它们是线程安全的。new/delete必须是线程安全的，但分配器不需要，并且boost文档没有说明。线程安全会增加开销。 - John5342

@VittorioRomeo 感谢您提供的SSVUtils参考，我已将其添加到上面的结果中。 - Henry Roeland

@VittorioRomeo：抱歉！我在测试中添加了PreAllocStatic<TestClass>。现在我使用了1MB的大小。这是正确的使用方式吗？请看代码，谢谢！ - Henry Roeland

显示剩余4条评论

2个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Ran Regev · Answer 1

当我需要一个快速的新/删除机制时，我自己编写了它。当然，我不得不妥协“通用动态分配内存”的要求。这种改进使我能够编写我所需的代码。

不需要数组。
预分配是必须的（像任何堆一样）。

这个想法非常简单 -

预先分配一个大小为所需对象的向量以实现快速分配/释放。例如：MyType preMyType [1000]
将预分配对象的地址推入堆栈中。
在新建时-弹出地址
在删除时-将返回的地址推回堆栈。

我将所有内容打包成了一个漂亮、易于使用的框架，对用户的要求很少。最终，它派生自某些类并声明初始大小。如果您愿意，我可以详细说明，包括代码示例。

- user1095108 · Answer 2

我曾经有一个疯狂的想法，就是用一个整数来代替可用插槽的数组。在这里查看：

https://code.google.com/p/cpppractice/source/browse/trunk/staticdelegate.hpp