make_shared (boost oder stl) scheint etwas langsamer als shared_ptr + neu in meinen Tests

Question

Ich habe ein wenig Zweifel, was ich über make_shared Leistung (Boost oder STL) verstehe, also wollte ich eine Meinung.

Ich arbeitete an einer App in C++ Ich musste einige Leistungstests durchführen, und ich endete, um make_shared und shared_ptr + new zu vergleichen (beachten Sie, dass es nicht der Leistungsverbesserung Zweck ist, und ich erwarte nicht Zeit hier zu gewinnen, aber ich bin nur neugierig jetzt) ​​

ich benutze

• Debian Jessy x64
• liboost 1.55
• gcc 4.9.2

Ich lese, dass make_shared ist effizienter, und nach den Erklärungen, die ich finden kann (Zuordnungsnummern, Overhead) scheint es mir logisch (soweit ich das verstehe).

Aber eine schnelle und dummen Test zu machen, ich verstehe nicht, was ich

 std::shared_ptr<MyUselessClass> dummyPtr = std::shared_ptr<MyUselessClass>(new MyUselessClass()); 
    auto start = boost::chrono::high_resolution_clock::now() ; 

    // - STD Share 
    std::shared_ptr<MyUselessClass> stdSharePtr = std::shared_ptr<MyUselessClass>(new MyUselessClass()); 
    auto stdSharePtrTime_1 = boost::chrono::high_resolution_clock::now() ; 

    // - STD Make 
    std::shared_ptr<MyUselessClass> stdMakePtr = std::make_shared<MyUselessClass>(); 
    auto stdMakePtrTime_2 = boost::chrono::high_resolution_clock::now() ; 

    // - BOOST Share 
    boost::shared_ptr<MyUselessClass> boostSharePtr = boost::shared_ptr<MyUselessClass>(new MyUselessClass()); 
    auto boostSharePtrTime_3 = boost::chrono::high_resolution_clock::now() ; 

    // - BOOST Make 
    boost::shared_ptr<MyUselessClass> boostMakePtr = boost::make_shared<MyUselessClass>(); 
    auto boostMakePtrTime_4 = boost::chrono::high_resolution_clock::now() ; 

    boost::chrono::nanoseconds stdShare = boost::chrono::duration_cast<boost::chrono::nanoseconds>(stdSharePtrTime_1-start) ; 
    boost::chrono::nanoseconds stdMake = boost::chrono::duration_cast<boost::chrono::nanoseconds>(stdMakePtrTime_2-stdSharePtrTime_1) ; 
    boost::chrono::nanoseconds boostShare = boost::chrono::duration_cast<boost::chrono::nanoseconds>(boostSharePtrTime_3-stdMakePtrTime_2) ; 
    boost::chrono::nanoseconds boostMake = boost::chrono::duration_cast<boost::chrono::nanoseconds>(boostMakePtrTime_4-boostSharePtrTime_3) ; 

    cout << "---" << endl ; 
    cout << "STD share " << stdShare << endl ; 
    cout << "BOOST share " << boostShare << endl ; 
    cout << "STD make " << stdMake << endl ; 
    cout << "BOOST make " << boostMake << endl ; 

MyUselessClass bekommen, ist eine einfache Klasse mit 3 Klassenattribute (Stachel, bool, int), und nur Konstruktor und desctructor.

Die „Ergebnisse“ (ich zitiere, weil es keine genaue Prüfung ist, natürlich) sind die folgenden: (i es in eine Schleife runned, gibt die gleichen Ergebnisse in durchschnittlich viele Iterationen zu bekommen):

STD share 162 nanoseconds 
    BOOST share 196 nanoseconds 
    STD make 385 nanoseconds 
    BOOST make 264 nanoseconds 

Wenn ich meinen Test glaube, ist make_shared etwas langsamer als der Aufruf von share_ptr & neue Instanciation. Ich hätte erwartet, wenn ich irgendwelche Unterschiede als Nanosekunden Präzision, um zu sehen, im Gegenteil ...

So, jetzt frage ich mich:

• Vielleicht mein Test zu dumm ist, nanosecons um keine Bedeutung hat in diese Operationen?
• Vielleicht habe ich einen Punkt in der Erklärung der besseren Leistung von make_shared verpasst?
• Vielleicht habe ich einige (mehrere) Punkte im Test verpasst?

Wenn Sie einige Antworten auf die folgenden Punkte haben, zögern Sie bitte nicht :)

Thanx

Answer 1

Versuchen Sie Ihr Programm mit -O2 kompilieren. Ich habe versucht, deinen Code ohne Optimierungen zu kompilieren und ich habe ähnliche Zahlen bekommen. Nach dem Kompilieren des Codes mit -O2 ist make_shared konsistent schneller. Die Größe der Klasse MyUselessClass beeinflusst übrigens auch das Verhältnis der Zeit.