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
Du musst angemeldet sein, um einen Kommentar abzugeben.
Es hat zu tun mit dem shared memory consistency model, dass die hardware implementiert. Für diejenigen hardware-Architektur, implementieren eine Art entspannter Konsistenz-Modell (z.B. release-Semantik), die starken Operationen, die Sie beziehen sich auf die oben haben einen hohen Aufwand und damit Experten die schwächeren Formen algorithmen implementieren, die Sie durchführen, sowie auch auf diejenigen, die entspannt Konsistenz Architekturen.
Für mehr info, siehe z.B.
http://www.hpl.hp.com/techreports/Compaq-DEC/WRL-95-7.pdf
Kapitel 12 und Anhang C in http://kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.html
InformationsquelleAutor der Antwort janneb
Den Hinweis gibt einen Anhaltspunkt, bezogen auf LL/SC Architekturen. Aus dem Wikipedia-Artikel:
Auf LL/SC-chips die
compare_exchange
umgesetzt werden in Bezug auf LL/SC, kann spuriously scheitern, socompare_exchange_strong
benötigt zusätzlichen Aufwand, um erneut in die Falle des Scheiterns. Sowohlcompare_exchange_strong
undcompare_exchange_weak
erlaubt es dem Programmierer, um zu entscheiden, ob Sie möchten, dass die Bibliothek zu behandeln, vermeidbare Fehler (in dem Fall würden Sie verwendencompare_exchange_strong
oder, wenn Sie wollen, behandeln Sie in Ihren eigenen code (in dem Fall würden Sie verwendencompare_exchange_weak
)InformationsquelleAutor der Antwort Jonathan Wakely