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