Namespaces
Variants

atomic_compare_exchange_weak, atomic_compare_exchange_strong, atomic_compare_exchange_weak_explicit, atomic_compare_exchange_strong_explicit

From cppreference.net
Definiert in Header <stdatomic.h>
_Bool atomic_compare_exchange_strong ( volatile A * obj,
C * expected, C desired ) ;
(1) (seit C11)
_Bool atomic_compare_exchange_weak ( volatile A * obj,
C * expected, C desired ) ;
(2) (seit C11)
_Bool atomic_compare_exchange_strong_explicit ( volatile A * obj,

C * expected, C desired,
memory_order succ,

memory_order fail ) ;
(3) (seit C11)
_Bool atomic_compare_exchange_weak_explicit ( volatile A * obj,

C * expected, C desired,
memory_order succ,

memory_order fail ) ;
(4) (seit C11)

Vergleicht atomar den Inhalt des Speichers, auf den obj zeigt, mit dem Inhalt des Speichers, auf den expected zeigt, und wenn diese bitweise gleich sind, ersetzt es den ersteren mit desired (führt einen Lese-Modifizieren-Schreibe-Vorgang aus). Andernfalls lädt es den tatsächlichen Inhalt des Speichers, auf den obj zeigt, in *expected (führt einen Ladevorgang aus).

Die Speichermodelle für die Lese-Modifizieren-Schreiben- und Ladeoperationen sind succ und fail jeweils. Die (1-2) Versionen verwenden standardmäßig memory_order_seq_cst .

Die schwachen Formen ((2) und (4)) der Funktionen können sporadisch fehlschlagen, das heißt, sie können sich so verhalten, als ob * obj ! = * expected selbst wenn sie gleich sind. Wenn ein Compare-and-Exchange in einer Schleife ausgeführt wird, liefert die schwache Version auf einigen Plattformen eine bessere Leistung. Wenn eine schwache Compare-and-Exchange-Operation eine Schleife erfordern würde und eine starke nicht, ist die starke vorzuziehen.

Dies ist eine generische Funktion , die für alle atomaren Objekttypen A definiert ist. Das Argument ist ein Zeiger auf einen flüchtigen atomaren Typ, um Adressen sowohl nicht-flüchtiger als auch flüchtiger (z.B. speichergemappter E/A) atomarer Objekte zu akzeptieren, und die flüchtige Semantik bleibt erhalten, wenn diese Operation auf flüchtige atomare Objekte angewendet wird. C ist der nicht-atomare Typ, der A entspricht.

Es ist nicht spezifiziert, ob der Name einer generischen Funktion ein Makro oder ein mit externer Bindung deklarierter Bezeichner ist. Wenn eine Makrodefinition unterdrückt wird, um auf eine tatsächliche Funktion zuzugreifen (z. B. in Klammern gesetzt wie ( atomic_compare_exchange ) ( ... ) ), oder ein Programm einen externen Bezeichner mit dem Namen einer generischen Funktion definiert, ist das Verhalten undefiniert.

Inhaltsverzeichnis

Parameter

obj - Zeiger auf das atomare Objekt, das getestet und modifiziert werden soll
expected - Zeiger auf den Wert, der voraussichtlich im atomaren Objekt gefunden wird
desired - der Wert, der im atomaren Objekt gespeichert werden soll, falls es den Erwartungen entspricht
succ - die Speichersynchronisationsreihenfolge für den Lese-Modifizier-Schreib-Vorgang bei erfolgreichem Vergleich. Alle Werte sind zulässig.
fail - die Speichersynchronisationsreihenfolge für den Ladevorgang bei fehlgeschlagenem Vergleich. Darf nicht memory_order_release oder memory_order_acq_rel sein und darf keine stärkere Reihenfolge als succ angeben.

Rückgabewert

Das Ergebnis des Vergleichs: true wenn *obj gleich *exp war, false andernfalls.

Hinweise

Das Verhalten der atomic_compare_exchange_* Familie ist so, als ob Folgendes atomar ausgeführt würde:

if (memcmp(obj, expected, sizeof *obj) == 0) {
    memcpy(obj, &desired, sizeof *obj);
    return true;
} else {
    memcpy(expected, obj, sizeof *obj);
    return false;
}

Referenzen

  • C17-Standard (ISO/IEC 9899:2018):
  • 7.17.7.4 Die atomic_compare_exchange-Generic-Funktionen (S: 207)
  • C11-Standard (ISO/IEC 9899:2011):
  • 7.17.7.4 Die atomic_compare_exchange-Generic-Funktionen (S: 283-284)

Siehe auch

tauscht einen Wert mit dem Wert eines atomaren Objekts
(Funktion)
C++-Dokumentation für atomic_compare_exchange_weak , atomic_compare_exchange_strong , atomic_compare_exchange_weak_explicit , atomic_compare_exchange_strong_explicit