Kann modernes C++ Ihnen Leistung kostenlos bringen?

Question

Es wird manchmal behauptet, dass C++ 11/14 Ihnen einen Leistungsschub bringen kann, selbst wenn Sie nur C++ 98 Code kompilieren. Die Begründung erfolgt normalerweise in der Bewegungssemantik, da in einigen Fällen die rvalue-Konstruktoren automatisch erzeugt werden oder jetzt Teil der AWL sind. Jetzt frage ich mich, ob diese Fälle zuvor schon von RVO oder ähnlichen Compiler-Optimierungen behandelt wurden.

Meine Frage ist dann, wenn Sie mir ein aktuelles Beispiel für einen Teil von C++ 98 Code geben könnten, der ohne Änderung schneller mit einem Compiler läuft, der die neuen Sprachfunktionen unterstützt. Ich verstehe, dass ein standardkonformer Compiler nicht erforderlich ist, um die Elision zu kopieren, und gerade deshalb könnte die Bewegungssemantik Geschwindigkeit bringen, aber ich würde gerne einen weniger pathologischen Fall sehen, wenn Sie so wollen.

EDIT: Nur um klar zu sein, ich frage nicht, ob neue Compiler schneller als alte Compiler sind, aber eher, wenn es Code gibt, wobei -std = C++ 14 zu meinen Compiler-Flags es schneller laufen würde (vermeiden Sie Kopien , aber wenn man mit etwas anderem außer bewegen Semantik kommen kann, würde mich interessieren, auch)

Answer 1

Ich kenne 5 allgemeine Kategorien, bei denen die Neukompilierung eines C++ 03-Compilers als C++ 11 unbegrenzte Leistungssteigerungen verursachen kann, die praktisch nichts mit der Qualität der Implementierung zu tun haben. Dies sind alle Variationen der Bewegungssemantik.

std::vector umverteilen

struct bar{ 
    std::vector<int> data; 
}; 
std::vector<bar> foo(1); 
foo.back().data.push_back(3); 
foo.reserve(10); // two allocations and a delete occur in C++03 

jedes Mal die foo ‚s Puffer umverteilt wird in C++ 03 es jedes vector in bar kopiert.

In C++ 11 verschiebt es stattdessen die bar::data s, die im Grunde frei ist.

In diesem Fall beruht dies auf Optimierungen innerhalb des std Containers vector. In jedem Fall unten ist die Verwendung von std Containern nur, weil sie C++ Objekte sind, die eine effiziente move Semantik in C++ 11 "automatisch" haben, wenn Sie Ihren Compiler aktualisieren. Objekte, die es nicht blockieren, die einen std Container enthalten, erben auch die automatisch verbesserten move-Konstruktoren.

NRVO Ausfall

Wenn NRVO (return genannt Wertoptimierung) ausfällt, in C++ 03 es wieder auf Kopie fällt, auf C 11 ++ es wieder Bewegung fällt. Ausfälle von NRVO sind einfach:

std::vector<int> foo(int count){ 
    std::vector<int> v; // oops 
    if (count<=0) return std::vector<int>(); 
    v.reserve(count); 
    for(int i=0;i<count;++i) 
    v.push_back(i); 
    return v; 
} 

oder sogar:

std::vector<int> foo(bool which) { 
    std::vector<int> a, b; 
    // do work, filling a and b, using the other for calculations 
    if (which) 
    return a; 
    else 
    return b; 
} 

Wir haben drei Werte - den Rückgabewert, und zwei verschiedene Werte innerhalb der Funktion. Elision ermöglicht, dass die Werte innerhalb der Funktion mit dem Rückgabewert "zusammengeführt" werden, aber nicht miteinander. Beide können nicht mit dem Rückgabewert zusammengeführt werden, ohne miteinander zu verschmelzen.

Das grundlegende Problem ist, dass NRVO Elision ist zerbrechlich, und Code mit Änderungen nicht in der Nähe der return Website kann plötzlich massive Leistungsreduzierungen an dieser Stelle ohne Diagnose emittiert haben. In den meisten NRVO-Fehlerfällen endet C++ 11 mit einer move, während C++ 03 mit einer Kopie endet.

Rückgabe eines Funktionsargument

Elision ist auch hier unmöglich:

std::set<int> func(std::set<int> in){ 
    return in; 
} 

in C++ 11 dieses billig ist: in C++ 03 gibt es keine Möglichkeit, die Kopie zu vermeiden. Argumente für Funktionen können nicht mit dem Rückgabewert verknüpft werden, da die Lebensdauer und die Position des Parameters und des Rückgabewerts vom aufrufenden Code verwaltet werden.

Allerdings kann C++ 11 von einem zum anderen wechseln. (In einem weniger Spielzeugbeispiel könnte etwas an der set getan werden).

push_back oder insert

Schließlich elision in Behälter geschieht nicht aber C++ 11 Überlastungen rvalue bewegen Einsatz Operatoren, die Kopien spart.

struct whatever { 
    std::string data; 
    int count; 
    whatever(std::string d, int c):data(d), count(c) {} 
}; 
std::vector<whatever> v; 
v.push_back(whatever("some long string goes here", 3)); 

in C++ 03 eine temporäre whatever erstellt wird, dann wird es in den Vektor v kopiert. 2 std::string Puffer werden zugeordnet, jeder mit identischen Daten und einer wird verworfen. In C++ 11 wird eine temporäre whatever erstellt. Die whatever&&push_back Überlastung dann move s, dass temporäre in den Vektor v. Ein std::string Puffer wird zugewiesen und in den Vektor verschoben. Ein leerer std::string wird verworfen.

Zuordnung

Stolen von @ Jarod42 Antwort unten.

Elision kann nicht mit Zuweisung auftreten, aber move-from kann.

std::set<int> some_function(); 

std::set<int> some_value; 

// code 

some_value = some_function(); 

hier some_function gibt einen Kandidaten aus elide, sondern weil es nicht verwendet wird, um ein Objekt direkt zu konstruieren, ist es nicht elided werden kann. In C++ 03 führt das obige dazu, dass der Inhalt des temporären Objekts in some_value kopiert wird. In C++ 11 wird es in some_value verschoben, was grundsätzlich frei ist.

---

Für die volle Wirkung der oben genannten, müssen Sie einen Compiler, der für Sie unterwegs und Zuweisungs synthetisiert.

MSVC 2013 implementiert Move-Konstruktoren in std Containern, jedoch nicht Move-Konstruktoren für Ihre Typen.

Also Typen, die std::vector s und ähnliche enthalten, erhalten solche Verbesserungen in MSVC2013 nicht, aber beginnen, sie in MSVC2015 zu erhalten.

clang und gcc haben seit langem implizite Move-Konstruktoren implementiert.Intels 2013-Compiler unterstützt die implizite Generierung von Move-Konstruktoren, wenn Sie -Qoption,cpp,--gen_move_operations übergeben (sie tun dies standardmäßig nicht, um mit MSVC2013 kompatibel zu sein).

Answer 2

, wenn Sie so etwas wie:

std::vector<int> foo(); // function declaration. 
std::vector<int> v; 

// some code 

v = foo(); 

Sie ++ eine Kopie in C bekam 03, während Du hast einen Umzug in C++ 11 bekommen. so haben Sie freie Optimierung in diesem Fall.