Kann und optimiert der Compiler zwei atomare Lasten? [duplicate]

Lesezeit: 3 Minuten

themagicalyang

Werden die beiden Lasten in solchen Szenarien zu einer zusammengefasst? Wenn dies architekturabhängig ist, was wäre dann bei modernen Prozessoren von beispielsweise Intel der Fall? Ich glaube, Atomlasten entsprechen normalen Lasten in Intel-Prozessoren.

void run1() {
    auto a = atomic_var.load(std::memory_order_relaxed);
    auto b = atomic_var.load(std::memory_order_relaxed);
   // Some code using a and b;
}

void run2() {
    if (atomic_var.load(std::memory_order_relaxed) == 2 && /*some conditions*/ ...) {
         if (atomic_var.load(std::memory_order_relaxed) * somevar > 3) {
               /*...*/
         }
    }
}

run1() und run2() sind einfach zwei Szenarien, die zwei Lasten derselben atomaren Variablen verwenden. Kann der Compiler solche Szenarien von zwei Ladevorgängen in einen Ladevorgang zusammenfassen und diesen wiederverwenden?

Entschuldigung, warum hast du beides run1 und run2? Können Sie Ihre Frage konkretisieren?

– Brian Bi

24. Januar ’17 um 5:23
@Brian Einfach zwei Szenarien. Bearbeitet.

– themagicalyang

24. Januar ’17 um 5:33

Die Antwort lautet derzeit also, dass der Standard dies zulässt, aber die modernen Compiler tun dies nicht und es wird immer noch diskutiert.

– themagicalyang

27. Januar ’17 um 7:36
Das ist wahrscheinlich richtig. Zumindest optimieren sie in diesem Fall nicht (viel). Vielleicht tun sie es in anderen Fällen. Sicherlich führen moderne optimierende Compiler Neuordnungen von Speichern und Laden um Atomics herum durch, soweit ihre Speicherordnungen dies zulassen. Für einen C++-Programmierer ist der C++-Standard die Schnittstelle zum Coden. Sich darauf zu verlassen, ob der Compiler etwas optimiert oder nicht, ist normalerweise keine gute Idee, da sonst mit jedem neuen Compiler-Update Fehler eingeführt werden können.

– Ralph Tandetzky

27. Januar ’17 um 9:14
Eine kürzlich gestellte Frage stellte dasselbe zum Zusammenführen von wiederholten Geschäften. Meine Antwort dort ist im Wesentlichen die gleiche wie Ihre Antwort hier, einschließlich der Verknüpfung von N4455 (aber auch wg21.link/p0062). Auch ein paar Sachen über warum Compiler entscheiden sich dafür, dies nicht zu tun, bis dies geklärt ist.

– Peter Cordes

2. September ’17 um 6:57
Wie auch immer, also habe ich dies als Duplikat des neuen geschlossen.

– Peter Cordes

2. September ’17 um 7:04
“Es gibt einige Diskussionen darüber, ob Compiler Atomik optimieren sollten” aber es gibt keine Debatte, dass die Optimierung in einem so einfachen Fall gültig ist

– neugieriger Typ

14. Dezember ’18 um 0:31

Ist es von der Norm erlaubt? Sagt volatile nicht, dass Sie jedes Mal laden müssen? Warum zählt das für atomar.

– themagicalyang

24. Januar ’17 um 7:31
@themagicalyang: std::atomic muss nicht verwenden volatile, und es sollte möglich sein, die beiden Lasten unter memory_order_relaxed. Sie können dies im Bug-Tracker von GCC melden und sehen, was sie sagen. Verlinken Sie es hier, wenn Sie dies tun!

– John Zwinck

24. Januar ’17 um 7:46
@themagicalyang: Wenn du willst volatile std::atomic<int> , dann benutze das. Aber du hast die Definition von weggelassen atomic_var Wir haben also keinen Grund anzunehmen, dass es volatile.

– MSalters

24. Januar ’17 um 11:22
Viele Informationen dazu finden Sie in JF Bastiens hervorragendem Beitrag: open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4455.html

– Matt Godbolt

24. Januar ’17 um 14:34

3198700cookie-checkKann und optimiert der Compiler zwei atomare Lasten? [duplicate]

#atomar #c++ #Compiler-Optimierung #gcc #x86