C++ 11 bestanden nach Wert des POD-Typs schlechter als const Referenz

Question

Diese Frage bezieht sich NICHT auf die Übergabe großer Objekte nach Wert oder Verweis - und auch nicht auf Verschiebungssemantik - wie viele andere Fragen.

Ich wollte wissen, wie klein ein POD-Typ sein muss, so dass es eine bessere Idee ist, es nach Wert und nicht durch const Referenz zu übergeben. Ich schrieb den folgenden Code:

#include <ctime> 
#include <iostream> 
#include <complex> 

using namespace std; 

using Number = double; //complex<double>; 

struct acc { 
    Number a; 
    void f(const Number& x) { a += x; } 
    void g(Number x) { a += x; } 
}; 

int main() 
{ 
    int n = 1000000000; 
    Number *v = new Number[n]; 

    for (int i = 0; i < n; i++) { 
    v[i] = Number(i); 
    } 

    clock_t b, e; 
    acc foo; 

#ifdef _const 
    b = clock(); 
    for (int i = 0; i < n; i++) 
    foo.f(v[i]); 

    e = clock(); 

    cout << ((double) e - b)/CLOCKS_PER_SEC << endl; 
#else 
    b = clock(); 
    for (int i = 0; i < n; i++) 
    foo.g(v[i]); 

    e = clock(); 

    cout << ((double) e - b)/CLOCKS_PER_SEC << endl; 
#endif 

    cout << foo.a << endl; 

    return 0; 
} 

ich mit gcc ohne Optimierung zusammengestellt.

Bei der Verwendung von Number = complex, const Referenz war schneller, und ich habe das ein bisschen erwartet. Aber die const-Referenz war auch schneller, wenn Number = double verwendet wurde, was mich völlig überrascht (in meinem Computer war es 3.5 für den Wert "pass-by-value" und 2.9 für den Wert const).

Warum ist das? Ist die Menge an Arbeit, einschließlich Speicherzugriff, in einem so einfachen Beispiel nicht gleich? Ich muss eine Template-Bibliothek schreiben, und ich wollte vorsichtig sein und Const-Referenzen oder Pass-by-Value verwenden, abhängig von der Größe der Template-Argumente, aber jetzt denke ich, dass es ziemlich nutzlos ist, sich darüber Gedanken zu machen. Hat noch jemand eine Ahnung, was vor sich geht?

Wenn ich mit Optimierung kompiliere, dann laufen beide Sorten gleich schnell.

Answer 1

Die Compiler-Autoren kümmern sich nicht darum, ob Ihr nicht optimierter Spielzeugcode in einem ähnlichen Fall um 20% langsamer ist. Deswegen.

Sie sollten auch nicht in einem extremen Fall, in dem Sie Ihre Debug-Build benötigen schnell genug sein, um einige weiche Echtzeitanforderungen zu erfüllen (z. B. ein Rendern alle X Hz oder Daten vor dem anderen Ende von eine Netzwerkverbindung überschreitet das Zeitlimit) und diese 20% ige Verlangsamung befindet sich auf einem kritischen Pfad.