Warum sollte ich std :: move std :: shared_ptr verschieben?

Ich habe den Clang-Quellcode durchgesehen und diesen Ausschnitt gefunden:

void CompilerInstance::setInvocation(
    std::shared_ptr<CompilerInvocation> Value) {
  Invocation = std::move(Value);
}

Warum sollte ich will std::moveein std::shared_ptr?

Gibt es einen Grund, das Eigentum an einer gemeinsam genutzten Ressource zu übertragen?

Warum sollte ich das nicht einfach stattdessen tun?

void CompilerInstance::setInvocation(
    std::shared_ptr<CompilerInvocation> Value) {
  Invocation = Value;
}

Ich denke, dass das eine, was die anderen Antworten nicht genug betonten, der Punkt der Geschwindigkeit ist .

std::shared_ptrReferenzzahl ist atomar . Das Erhöhen oder Verringern des Referenzzählers erfordert ein atomares Inkrementieren oder Dekrementieren . Dies ist hundertmal langsamer als nicht-atomares Inkrementieren / Dekrementieren, ganz zu schweigen davon, dass wir, wenn wir denselben Zähler inkrementieren und dekrementieren, die genaue Zahl erhalten und dabei eine Menge Zeit und Ressourcen verschwenden.

Indem shared_ptrwir das verschieben, anstatt es zu kopieren, "stehlen" wir den atomaren Referenzzähler und heben den anderen auf shared_ptr. Das "Stehlen" des Referenzzählers ist nicht atomar und es ist hundertmal schneller als das Kopieren des shared_ptr(und verursacht ein Inkrementieren oder Dekrementieren der atomaren Referenz).

Beachten Sie, dass diese Technik nur zur Optimierung verwendet wird. Das Kopieren (wie Sie vorgeschlagen haben) ist in Bezug auf die Funktionalität genauso gut.

Durch die Verwendung movevermeiden Sie, die Anzahl der Freigaben zu erhöhen und dann sofort zu verringern. Das könnte Ihnen einige teure atomare Operationen bei der Anzahl der Nutzungen ersparen.

Verschiebungsoperationen (wie der Verschiebungskonstruktor) für std::shared_ptrsind billig , da sie im Grunde genommen "Zeiger stehlen" (von Quelle zu Ziel; genauer gesagt, der gesamte Statussteuerblock wird von Quelle zu Ziel "gestohlen", einschließlich der Referenzzählinformationen). .

Stattdessen erhöhen sich die Kopiervorgänge beim std::shared_ptrAufrufen der Anzahl der Atomreferenzen (dh nicht nur ++RefCountbei einem ganzzahligen RefCountDatenelement, sondern z. B. beim Aufrufen InterlockedIncrementvon Windows), was teurer ist als nur das Stehlen von Zeigern / Status.

Analyse der Ref-Count-Dynamik dieses Falls im Detail:

// shared_ptr<CompilerInvocation> sp;
compilerInstance.setInvocation(sp);

Wenn Sie einen spWert übergeben und dann eine Kopie innerhalb der CompilerInstance::setInvocationMethode erstellen, haben Sie:

1. Bei der Eingabe der Methode wird der shared_ptrParameter kopierkonstruiert: ref count atomares Inkrement .
2. Innerhalb des Hauptteils der Methode kopieren Sie den shared_ptrParameter in das Datenelement: ref count atomares Inkrement .
3. Beim Beenden der Methode wird der shared_ptrParameter zerstört: ref count atomares Dekrement .

Sie haben zwei atomare Inkremente und ein atomares Dekrement für insgesamt drei atomare Operationen.

Wenn Sie stattdessen den shared_ptrParameter als Wert und dann std::moveinnerhalb der Methode übergeben (wie in Clangs Code korrekt ausgeführt), haben Sie:

1. Bei der Eingabe der Methode wird der shared_ptrParameter kopierkonstruiert: ref count atomares Inkrement .
2. Innerhalb des Methodenkörpers geben Sie std::moveden shared_ptrParameter in das Datenelement ein: ref count ändert sich nicht ! Sie stehlen nur Zeiger / Status: Es sind keine teuren atomaren Ref-Count-Operationen erforderlich.
3. Beim Beenden der Methode wird der shared_ptrParameter zerstört. Aber seit Sie in Schritt 2 umgezogen sind, gibt es nichts zu zerstören, da der shared_ptrParameter auf nichts mehr zeigt. Auch in diesem Fall findet keine atomare Dekrementierung statt.

Fazit: In diesem Fall erhalten Sie nur ein Atominkrement für die Ref-Anzahl, dh nur eine Atomoperation .
Wie Sie sehen können, ist dies viel besser als zwei atomare Inkremente plus ein atomares Dekrement (für insgesamt drei atomare Operationen) für den Kopierfall.

Beim Kopieren von a wird shared_ptrder interne Statusobjektzeiger kopiert und der Referenzzähler geändert. Beim Verschieben werden nur Zeiger auf den internen Referenzzähler und das eigene Objekt ausgetauscht, sodass es schneller geht.

In dieser Situation gibt es zwei Gründe für die Verwendung von std :: move. Die meisten Antworten befassten sich mit dem Thema Geschwindigkeit, ignorierten jedoch das wichtige Problem, die Absicht des Codes klarer darzustellen.

Bei einem std :: shared_ptr bezeichnet std :: move eindeutig eine Eigentumsübertragung des Pointees, während ein einfacher Kopiervorgang einen zusätzlichen Eigentümer hinzufügt. Wenn der ursprüngliche Eigentümer später sein Eigentum aufgibt (z. B. indem er zulässt, dass sein std :: shared_ptr zerstört wird), wurde natürlich eine Eigentumsübertragung durchgeführt.

Wenn Sie das Eigentum mit std :: move übertragen, ist es offensichtlich, was passiert. Wenn Sie eine normale Kopie verwenden, ist es nicht offensichtlich, dass es sich bei dem beabsichtigten Vorgang um eine Übertragung handelt, bis Sie überprüfen, ob der ursprüngliche Eigentümer das Eigentum sofort aufgibt. Als Bonus ist eine effizientere Implementierung möglich, da durch eine atomare Eigentumsübertragung der vorübergehende Zustand vermieden werden kann, in dem sich die Anzahl der Eigentümer um eins erhöht hat (und die damit verbundenen Änderungen der Referenzzählungen).

Mindestens mit libstdc ++ sollten Sie die gleiche Leistung mit Bewegung und Zuordnung , da bekommen operator=Anrufe std::moveauf dem eingehenden Zeiger. Siehe: https://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/include/bits/shared_ptr.h#L384