std::atomic<std::shared_ptr>::wait should compare control blocks

[fsb4000]

Fixes #3602

[StephanTLavavej]

After hiding from this PR for a year 😹, I've finally looked at it and I believe I'm comfortable with the change (after pushing a fix/test for "owning the null pointer"). I'm definitely happy that @AlexGuteniev's suggested test case has been added, I don't think that this poses significant regression risks, and I don't think that there's any vNext interaction (this is just a behavioral change; mix-and-match scenarios shouldn't be harmed beyond maybe not getting the fix).

Edit: I've been convinced on Discord that we are, in fact, doomed. ☠️

[AlexGuteniev]

I'm afraid the PR doesn't fully fix hang in any of the scenario - it only makes hangs unlikely, but still possible, thus introducing inconsistency.

[AlexGuteniev]

I don't want to provide an example anymore as there's a consensus that the problem is very infrequently reproducible, yet existent.

@StephanTLavavej suggested that we can have timeout for correctness, @BillyONeal suggested that exponential back-off is an acceptable implementation of atomic wait.

We can try our best and make atomic wait with exponential timeout. This is not abi-breaking, as we still wait on the same address. I think that the PR should be closed with this PR with exponential back-out added.

Another issue can be open to consider something better for vNext. Note that SRWLOCK+CONDITION_VARIABLE isn't necessarily better due to space overhead and extra atomic ops.

[StephanTLavavej]

I'm speculatively mirroring this to the MSVC-internal repo - please notify me if any further changes are pushed.

[CaseyCarter]

No change requested; we should do this in a followup if at all to avoid resetting testing, since it's not a correctness issue. Should this be reordered as:

Suggested change

	bool _Equal = _Ptr.load(memory_order_relaxed) == _Old_ptr && _Rep == _Old_rep;
	bool _Equal = _Rep == _Old_rep && _Ptr.load(memory_order_relaxed) == _Old_ptr;

so we short-circuit when the core-local _Rep == _Old_rep is false before potentially loading _Ptr's cache line from some other core's data cache? (I suspect I understand cache coherence protocols just well enough to be dangerous.) Would any difference just be noise compared to the expense of _Repptr._Lock_and_load()?

[CaseyCarter]

(Pulling in @AlexGuteniev to render an opinion and/or tell me how wrong I am 😄.)

[StephanTLavavej]

My vague understanding is that a relaxed load has no barriers, so it has no special costs. It would be fine to reorder, though, since the .load is at least a debug mode function call.

[Alcaro]

Aren't _Repptr and _Ptr in the same cache line? Sure, whatever they point to can be anywhere, but the pointers themselves are (as far as I can see) right beside each other.

(STL's comment sounds accurate, though.)

[AlexGuteniev]

I agree that they are always in the same cache line (it is really always, not just most of the time, because we over align to alignas(2 * sizeof(void*))). So from the cache perspective it does not matter.

I agree also that eliminating debug mode call can be potentially beneficial.

Still I more like the original order, because we compare _Rep == _Old_rep; the very last thing, as close to wait as possible, so reduce the probability of resorting to timeout.

[Alcaro]

Considering _Rep is just a stack-local and the real load is on the line above, I can't quite follow your reasoning.

[AlexGuteniev]

Considering _Rep is just a stack-local and the real load is on the line above, I can't quite follow your reasoning.

Hm, you are right, we done loading it into register at the same time anyway.

Then debug mode call saving could be the main decision factor here.

[CaseyCarter]

Ah, I'd forgotten that we overalign - my cache coherence point is invalid. +1 to avoiding the call in debug compiles, though. We really want to minimize the time between load and check.

[StephanTLavavej]

Thanks for fixing this runtime correctness bug - what a rollercoaster of despair and elation! 📉 📈 😹 🎉