std :: atomar | compare_exchange_weak vs. compare_exchange_strong

Ich noch unsicher bin, ob es mir nicht zu verstehen, oder die Dokumentation ist nicht eindeutig formuliert.
Der folgende Auszug wurde aus dem neuesten Entwurf (N3126, Kapitel 29.6):

bool atomic_compare_exchange_weak(volatile A* object, C * expected, C desired);
bool atomic_compare_exchange_weak(A* object, C * expected, C desired);
bool atomic_compare_exchange_strong(volatile A* object, C * expected, C desired);
bool atomic_compare_exchange_strong(A* object, C * expected, C desired);
bool atomic_compare_exchange_weak_explicit(volatile A* object, C * expected, C desired, memory_order success, memory_order failure);
bool atomic_compare_exchange_weak_explicit(A* object, C * expected, C desired, memory_order success, memory_order failure);
bool atomic_compare_exchange_strong_explicit(volatile A* object, C * expected, C desired, memory_order success, memory_order failure);
bool atomic_compare_exchange_strong_explicit(A* object, C * expected, C desired, memory_order success, memory_order failure);
bool A::compare_exchange_weak(C & expected, C desired, memory_order success, memory_order failure) volatile;
bool A::compare_exchange_weak(C & expected, C desired, memory_order success, memory_order failure);
bool A::compare_exchange_strong(C & expected, C desired, memory_order success, memory_order failure) volatile;
bool A::compare_exchange_strong(C & expected, C desired, memory_order success, memory_order failure);
bool A::compare_exchange_weak(C & expected, C desired, memory_order order = memory_order_seq_cst) volatile;
bool A::compare_exchange_weak(C & expected, C desired, memory_order order = memory_order_seq_cst);
bool A::compare_exchange_strong(C & expected, C desired, memory_order order = memory_order_seq_cst) volatile;
bool A::compare_exchange_strong(C & expected, C desired, memory_order order = memory_order_seq_cst);

Bemerkung: Die schwachen Vergleich-und-Austausch
Vorgänge können fehlschlagen, spuriously, dass
ist, false zurück, während er die
Inhalt der Speicher verweist
erwartet vor der operation ist die
gleiche, die gleiche wie die des Objekts
und das gleiche wie erwartet nach
der Betrieb. [ Hinweis: Diese unechten
Ausfall ermöglicht die Umsetzung von
vergleichen-und-Austausch auf eine breitere
Klasse von Maschinen, z.B., loadlocked
store-conditional-Maschinen. Ein
Folge vermeidbarer Fehler ist
nahezu alle Verwendungen von schwach
vergleichen-und-Tausch wird in einer
loop.

So, was bedeutet das? Erstens, es 'kann' faild spuriously?! Warum es funktioniert? Und wie definieren Sie überhaupt "kann"? Zweitens, ich weiß nicht warum, aber ich habe immer noch keine Ahnung, was der Unterschied zwischen den Funktionen mit "_strong" und "_weak" - suffix.

Hoffe, dass jemand helfen kann 😉
Beste Grüße.

BEARBEITEN:
Das ist, was ich gefunden habe in libstdc++-Implementierung (atomic_0.h):

bool compare_exchange_weak(
    __integral_type& __i1,
    __integral_type __i2,
    memory_order __m1,
    memory_order __m2
)
{
    __glibcxx_assert(__m2 != memory_order_release);
    __glibcxx_assert(__m2 != memory_order_acq_rel);
    __glibcxx_assert(__m2 <= __m1);
    return _ATOMIC_CMPEXCHNG_(this, &__i1, __i2, __m1);
}

bool compare_exchange_strong(
    __integral_type& __i1,
    __integral_type __i2,
    memory_order __m1,
    memory_order __m2
)
{
    __glibcxx_assert(__m2 != memory_order_release);
    __glibcxx_assert(__m2 != memory_order_acq_rel);
    __glibcxx_assert(__m2 <= __m1);
    return _ATOMIC_CMPEXCHNG_(this, &__i1, __i2, __m1);
}

InformationsquelleAutor der Frage 0xbadf00d | 2011-02-09

Schreibe einen Kommentar