Understanding std::atomic::compare_exchange_weak() in C++11

Question

bool compare_exchange_weak (T& expected, T val, ..);

compare_exchange_weak() is one of compare-exchange primitives provided in C++

Answer 1

Why does it have to be in a loop in nearly all uses ?

Because if you don't loop and it fails spuriously your program hasn't done anything useful - you didn't update the atomic object and you don't know what its current value is (Correction: see comment below from Cameron). If the call doesn't do anything useful what's the point of doing it?

Does that mean we shall loop when it fails because of spurious failures?

Yes.

If that's the case, why do we bother use compare_exchange_weak() and write the loop ourselves? We can just use compare_exchange_strong() which I think should get rid of spurious failures for us. What are the common use cases of compare_exchange_weak()?

On some architectures compare_exchange_weak is more efficient, and spurious failures should be fairly uncommon, so it might be possible to write more efficient algorithms using the weak form and a loop.

In general it is probably better to use the strong version instead if your algorithm doesn't need to loop, as you don't need to worry about spurious failures. If it needs to loop anyway even for the strong version (and many algorithms do need to loop anyway), then using the weak form might be more efficient on some platforms.

Why is !expected there in the loop condition?

The value could have got set to true by another thread, so you don't want to keep looping trying to set it.

Edit:

But as analyzed above, two versions in a loop should give the same/similar performance. What's the thing I miss?

Surely it's obvious that on platforms where spurious failure is possible the implementation of compare_exchange_strong has to be more complicated, to check for spurious failure and retry.

The weak form just returns on spurious failure, it doesn't retry.