c++ - std::atomic | compare_exchange_weak vs. compare_exchange_strong -
i'm still unsure if it's me don't understanding or documentation isn't formulated. following excerpt has been taken newest draft (n3126, section 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);
remark: weak compare-and-exchange operations may fail spuriously, is, return false while leaving contents of memory pointed expected before operation same same of object , same of expected after operation. [ note: spurious failure enables implementation of compare-and-exchange on broader class of machines, e.g., loadlocked store-conditional machines. consequence of spurious failure uses of weak compare-and-exchange in loop.
so, mean? firstly, 'may' faild spuriously?! why does? , how define 'may'? secondly, don't know why, still have no idea what's difference between functions "_strong" , "_weak" suffix.
hope can ;) best regards.
edit: that's i've found in libstdc++-implementation (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); }
it has shared memory consistency model hardware implements. hardware architectures implement kind of relaxed consistency model (e.g. release semantics), strong operations refer above can have high overhead, , experts can use weaker forms implement algorithms perform on relaxed consistency architectures.
for more info, see e.g.
http://www.hpl.hp.com/techreports/compaq-dec/wrl-95-7.pdf
chapter 12 , appendix c in http://kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.html
Comments
Post a Comment