On 7/19/22 11:01, language.lawyer_at_[hidden] wrote:
> On 19/07/2022 12:30, Andrey Semashev via Std-Discussion wrote:
>> On 7/19/22 09:58, language.lawyer_at_[hidden] wrote:
>>> On 19/07/2022 11:43, Andrey Semashev via Std-Discussion wrote:
>>>> It means the store happens-before notify_one (in the non-main thread).
>>>>
>>>> Coherence-ordered before is the relation between the store and the
>>>> wait in the two threads.
>>>> It says that when the store is coherence-ordered before the wait in
>>>> the modification order of the atomic, the wait will observe the
>>>> effects of the store.
>>>
>>> To me, http://eel.is/c++draft/atomics.order#3 reads in the opposite
>>> direction. If the wake-up read observes the new value, it will become
>>> coherence-ordered before. But if it does not observe, it won't.
>>> So, what guarantees it will observe the new value?
>>
>> If the wait doesn't observe the store, it blocks. And in that case, it
>> unblocks when it observes the notify, which happens-after the store. So
>> if the wait is unblocked by notify, it must also observe the store on
>> the second load.
>
> Yes, the invocation of notify_one happens-after the store in the
> non-main thread.
> notify_one «Unblocks the execution of at least one atomic waiting
> operation...»
> (https://timsong-cpp.github.io/cppwp/n4861/atomics.types.operations#32)
> The waiting thread «Blocks until it is unblocked by an atomic notifying
> operation»
> (https://timsong-cpp.github.io/cppwp/n4861/atomics.types.operations#30.3)
>
> So, now, what is the relation between the invocation of notify_one and
> the unblock of the waiting thread?

I have said this before:

http://eel.is/c++draft/atomics#wait-4

<quote>
A call to an atomic waiting operation on an atomic object M is eligible
to be unblocked by a call to an atomic notifying operation on M if there
exist side effects X and Y on M such that:

- the atomic waiting operation has blocked after observing the result of X,
- X precedes Y in the modification order of M, and
- Y happens before the call to the atomic notifying operation.
</quote>

Here, X is the initial initialization of the atomic to false, Y is the
store of true. This says that the wait is eligible to be unblocked by
the notify (and it will return if the effects of Y satisfies the wait
condition).

> Does it synchronize-with it? Does
> https://timsong-cpp.github.io/cppwp/n4861/atomics.types.operations#30.3
> happen-after the invocation of notify_one in any other way? If not, then
> why
> https://timsong-cpp.github.io/cppwp/n4861/atomics.types.operations#30.3
> must observe the new value?

The waiting thread is unblocked and observes the new value. It must not
get never unblocked because it contradicts the "eligible to be
unblocked" requirement between the notify and wait. It cannot be
unblocked and not observe the store because it contradicts the
"happens-before" requirement between the store and notify.

I'm really running out of ways of saying the same thing over and over
again in this thread.