Why does std :: make_shared <> () have much better performance than boost :: make_shared ()?

Question

I tested field performance on

 1>std::shared_ptr, std::make_shared based on 'gcc 4.7.2' & 'VC10 implementation' 2>boost::shared_ptr, boost::make_shared based on boost 1.47 

The test result is somewhat interesting.

1> Usually the std version works better, but especially std::make_shared . What for? Can I increase the performance of the boost version since C ++ 11 is not available for some old project while using the old version of Visual Studio?

The following is a snippet of code used for testing. NB. you need to manually switch between boost and std. NB. "SimpleMSTimer.hpp" is my timer program to increase ptime, too long to post here. But feel free to use your own timer. Any portable time will do.

 #include "stdafx.h" #include <vector> #include <iostream> #include <boost/shared_ptr.hpp> #include <boost\make_shared.hpp> #include "SimpleMSTimer.hpp"//my timer wrapper for boost ptime using namespace std; using namespace boost; class Thing { public: Thing() { } void method (void) { int i = 5; } }; typedef boost::shared_ptr<Thing> ThingPtr; void processThing(Thing* thing) { thing->method(); } //loop1 and loop2 test shared_ptr in the vector container void loop1(long long num) { cout << "native raw pointer: "; vector<Thing> thingPtrs; YiUtil::MSSegmentTimer segTimer(YiUtil::MSSegmentTimer::MLSEC, std::cout); for(int i=0; i< num; i++) { Thing thing; thingPtrs.push_back(thing); } thingPtrs.clear(); } void loop2(long long num) { cout << "native boost::shared_ptr: "; vector<ThingPtr> thingPtrs; YiUtil::MSSegmentTimer segTimer(YiUtil::MSSegmentTimer::MLSEC, std::cout); for(int i=0; i< num; i++) { ThingPtr p1(new Thing); thingPtrs.push_back(p1); } } void loop3(long long num) { cout << "optimized boost::shared_ptr: "; vector<ThingPtr> thingPtrs; YiUtil::MSSegmentTimer segTimer(YiUtil::MSSegmentTimer::MLSEC, std::cout); for(int i=0; i< num; i++) { ThingPtr p1 = boost::make_shared<Thing>(); thingPtrs.push_back(p1); } } //loop3 and loop4 test shared_ptr in loop void loop4(long long num) { cout << "native raw pointer: "; YiUtil::MSSegmentTimer segTimer(YiUtil::MSSegmentTimer::MLSEC, std::cout); for(int i=0; i< num; i++) { Thing* p1 = new Thing(); processThing(p1); delete p1; } } void loop5(long long num) { cout << "native boost::shared_ptr: "; YiUtil::MSSegmentTimer segTimer(YiUtil::MSSegmentTimer::MLSEC, std::cout); for(int i=0; i< num; i++) { ThingPtr p1(new Thing); processThing(p1.get()); } } void loop6(long long num) { cout << "optimized boost::shared_ptr: "; YiUtil::MSSegmentTimer segTimer(YiUtil::MSSegmentTimer::MLSEC, std::cout); for(int i=0; i< num; i++) { ThingPtr p1 = boost::make_shared<Thing>(); processThing(p1.get()); } } int main() { long long num = 10000000; cout << "test 1" << endl; loop1(num); loop2(num); loop3(num); cout << "test 2"<< endl; loop4(num); loop5(num); loop6(num); return 0; } 

VC10 compiler in release mode, gcc compiled with the '-O3' flag for maximum optimization. Test result:

 //VS2010 release mode //boost test 1 native raw pointer: SegmentTimer: 15 milliseconds/n native boost::shared_ptr: SegmentTimer: 3312 milliseconds/n optimized boost::shared_ptr: SegmentTimer: 3093 milliseconds/n test 2 native raw pointer: SegmentTimer: 921 milliseconds/n native boost::shared_ptr: SegmentTimer: 2359 milliseconds/n optimized boost::shared_ptr: SegmentTimer: 2203 milliseconds/n //std test 1 native raw pointer: SegmentTimer: 15 milliseconds/n native std::shared_ptr: SegmentTimer: 3390 milliseconds/n optimized std::shared_ptr: SegmentTimer: 2203 milliseconds/n test 2 native raw pointer: SegmentTimer: 937 milliseconds/n native std::shared_ptr: SegmentTimer: 2359 milliseconds/n optimized std::shared_ptr: SegmentTimer: 1343 milliseconds/n ============================================================================== gcc 4.72 release mode //boost test 1 native raw pointer: SegmentTimer: 15 milliseconds/n native boost::shared_ptr: SegmentTimer: 4874 milliseconds/n optimized boost::shared_ptr: SegmentTimer: 3687 milliseconds/n test 2 native raw pointer: SegmentTimer: 1109 milliseconds/n native boost::shared_ptr: SegmentTimer: 2546 milliseconds/n optimized boost::shared_ptr: SegmentTimer: 1578 milliseconds/n //std test 1 native raw pointer: SegmentTimer: 15 milliseconds/n native std::shared_ptr: SegmentTimer: 3374 milliseconds/n optimized std::shared_ptr: SegmentTimer: 2296 milliseconds/n test 2 native raw pointer: SegmentTimer: 1124 milliseconds/n native std::shared_ptr: SegmentTimer: 2531 milliseconds/n optimized std::shared_ptr: SegmentTimer: 1468 milliseconds/n 

Answer 1

They work much better because the Boost version is not updated to use rvalue links that allow semantics to be moved. While C ++ 11 versions use move semantics. This means that the Boost version has to be copied quite often. If you test on the pre-C ++ 11 compiler, your target base (with std::tr1::shared_ptr ), they should do much more.