lars-t-hansen
commented
7 years ago I think that in essence the semantics will be as follows. Recall that a WaiterList pertains to a particular word address in shared memory and is a FIFO of the agents that are waiting on that location.
- the WaiterList is now polymorphic and holds either an agent signifier, as before (for agents that wait synchronously) or a tuple of agent signifier and promise (for agents that wait asynchronously)
- when waking an item that is the tuple of signifier and promise we make the promise resolvable and it gets inserted into the job queue in some standard way
- an agent can be on the WaiterList several times (eg an agent can waitAsync several times before being woken and thus end up on the list multiple times), but at most once synchronously
- if an agent waits synchronously while it has outstanding async waits on the WaiterList, the datum for the sync wait should probably be inserted on the WaiterList ahead of any async waits, thus violating FIFO order. Otherwise, consider what happens if another agent performs a wake with a count of 1 and the async waits are first: nothing will happen, because the waiting agent is blocked in a sync wait which can't be broken just because an async wait ended. (Inserting an async wait need not look for a sync wait on the list because there will be none, it can just add the tuple to the end.)
An argument against breaking the FIFO order is that the FIFO order is easy to remember, and the polyfill models it properly, and we can simply pretend that each async wait forks off a new agent that performs the wait for it - a very simple model. But I still think this is wrong.
littledan
Right now there's a section titled "Informal semantics (aka useful facts)" that hints at what the semantics should be, and then there's the polyfill implementing semantics roughly like that.
What we need is to pin down the semantics more thoroughly. Some of the clauses in the informal semantics are known to contradict each other (and there's a note to that effect in the text); this contradiction must be resolved. Mostly, the problems here surround the observable wakeup order, which is tricky because an agent waiting asynchronously can both wait several times (on the same and on different locations) and can even wake up sleeping instances of itself. Only by placing this proposal into the framework established by ES2017 (both for promises and for wait/wake) can we hope to get firm semantics.