Remove yielding behavior of waitable-set.poll to allow it to be called from synchronous functions

Author: lukewagner

design/mvp/CanonicalABI.md

@@ -767,7 +767,7 @@ class WaitableSet:
 The `WaitableSet.drop` method traps if dropped while it still contains elements
 (whose `Waitable.wset` field would become dangling) or if it is being
 waited-upon by another `Task` (as indicated by the `num_waiting` field, which
-is incremented/decremented by `Task.{wait,poll}_for_event` below).
+is incremented/decremented by `Task.wait_until` below).
 
 The `random.shuffle` in `get_pending_event` give embedders the semantic freedom
 to schedule delivery of events nondeterministically (e.g., taking into account
@@ -1042,31 +1042,10 @@ trap if another task tries to drop the waitable set being used.
     return event
 ```
 
-The `Task.poll_until` method is called by `canon_waitable_set_poll` and from
-the event loop in `canon_lift` when `CallbackCode.POLL` is returned. Unlike
-`wait_until`, `poll_until` does not wait for the given waitable set to have a
-pending event, returning `EventCode.NONE` if there is none already. However,
-`poll_until` *does* call `suspsend_until` to allow the runtime to
-nondeterministically switch to another task (or not).
-```python
-  def poll_until(self, ready_func, thread, wset, cancellable) -> Optional[EventTuple]:
-    assert(thread in self.threads and thread.task is self)
-    wset.num_waiting += 1
-    match self.suspend_until(ready_func, thread, cancellable):
-      case SuspendResult.CANCELLED:
-        event = (EventCode.TASK_CANCELLED, 0, 0)
-      case SuspendResult.NOT_CANCELLED:
-        if wset.has_pending_event():
-          event = wset.get_pending_event()
-        else:
-          event = (EventCode.NONE, 0, 0)
-    wset.num_waiting -= 1
-    return event
-```
-
 The `Task.yield_until` method is called by `canon_thread_yield` and from
-the event loop in `canon_lift` when `CallbackCode.YIELD` is returned.
-`yield_until` works like `poll_until` if given a fresh empty waitable set.
+the event loop in `canon_lift` when `CallbackCode.YIELD` is returned and
+calls `suspend_until` to allow the runtime to nondeterministically switch to
+another task (or not).
 ```python
   def yield_until(self, ready_func, thread, cancellable) -> EventTuple:
     assert(thread in self.threads and thread.task is self)
@@ -3287,11 +3266,8 @@ function (specified as a `funcidx` immediate in `canon lift`) until the
           wset = inst.table.get(si)
           trap_if(not isinstance(wset, WaitableSet))
           event = task.wait_until(lambda: not inst.exclusive, thread, wset, cancellable = True)
-        case CallbackCode.POLL:
-          trap_if(not task.may_block())
-          wset = inst.table.get(si)
-          trap_if(not isinstance(wset, WaitableSet))
-          event = task.poll_until(lambda: not inst.exclusive, thread, wset, cancellable = True)
+        case _:
+          trap()
       thread.in_event_loop = False
       inst.exclusive = True
       event_code, p1, p2 = event
@@ -3300,17 +3276,17 @@ function (specified as a `funcidx` immediate in `canon lift`) until the
     task.exit()
     return
 ```
-The `Task.{wait,poll,yield}_until` methods called by the event loop are the
-same methods called by the `yield`, `waitable-set.wait` and `waitable-set.poll`
-built-ins. Thus, the main difference between stackful and stackless async is
-whether these suspending operations are performed from an empty or non-empty
-core wasm callstack (with the former allowing additional engine optimization).
+The `Task.{wait,yield}_until` methods called by the event loop are the same
+methods called by the `yield` and `waitable-set.wait` built-ins. Thus, the
+main difference between stackful and stackless async is whether these
+suspending operations are performed from an empty or non-empty core wasm
+callstack (with the former allowing additional engine optimization).
 
 If a `Task` is not allowed to block (because it was created for a non-`async`-
 typed function call and has not yet returned a value), `YIELD` is always a
-no-op and `WAIT` and `POLL` always trap. Thus, a component may implement a
+no-op and `WAIT` always traps. Thus, a component may implement a
 non-`async`-typed function with the `async callback` ABI, but the component
-*must* call `task.return` *before* returning `WAIT` or `POLL`.
+*must* call `task.return` *before* returning `WAIT`.
 
 The event loop also releases `ComponentInstance.exclusive` (which was acquired
 by `Task.enter` and will be released by `Task.exit`) before potentially
@@ -3346,8 +3322,7 @@ class CallbackCode(IntEnum):
   EXIT = 0
   YIELD = 1
   WAIT = 2
-  POLL = 3
-  MAX = 3
+  MAX = 2
 
 def unpack_callback_result(packed):
   code = packed & 0xf
@@ -3357,7 +3332,7 @@ def unpack_callback_result(packed):
   waitable_set_index = packed >> 4
   return (CallbackCode(code), waitable_set_index)
 ```
-The ability to asynchronously wait, poll, yield and exit is thus available to
+The ability to asynchronously wait, yield and exit is thus available to
 both the `callback` and non-`callback` cases, making `callback` just an
 optimization to avoid allocating stacks for async languages that have avoided
 the need for stackful coroutines by design (e.g., `async`/`await` in JS,
@@ -3888,26 +3863,22 @@ validation specifies:
 * `$f` is given type `(func (param $si i32) (param $ptr i32) (result i32))`
 * 🚟 - `cancellable` is allowed (otherwise it must be absent)
 
-Calling `$f` invokes the following function, which returns `NONE` (`0`) instead
-of blocking if there is no event available, and otherwise returns the event the
-same way as `wait`.
+Calling `$f` invokes the following function, which either returns an event that
+was pending on one of the waitables in the given waitable set (the same way as
+`waitable-set.wait`) or, if there is none, returns `0`.
 ```python
 def canon_waitable_set_poll(cancellable, mem, thread, si, ptr):
   trap_if(not thread.task.inst.may_leave)
-  trap_if(not thread.task.may_block())
   wset = thread.task.inst.table.get(si)
   trap_if(not isinstance(wset, WaitableSet))
-  event = thread.task.poll_until(lambda: True, thread, wset, cancellable)
+  if thread.task.deliver_pending_cancel(cancellable):
+    event = (EventCode.TASK_CANCELLED, 0, 0)
+  elif not wset.has_pending_event():
+    event = (EventCode.NONE, 0, 0)
+  else:
+    event = wset.get_pending_event()
   return unpack_event(mem, thread, ptr, event)
 ```
-Even though `waitable-set.poll` doesn't block until the given waitable set has
-a pending event, `poll_until` does transitively perform a `Thread.suspend`
-which allows the embedder to nondeterministically switch to executing another
-task (like `thread.yield`). To avoid encouraging spin-waiting and to support
-hosts like browsers that require returning to the event loop for async I/O to
-resolve, a non-`async`-typed function export that has not yet returned a value
-unconditionally traps if it transitively attempts to call `poll`.
-
 If `cancellable` is set, then `waitable-set.poll` will return whether the
 supertask has already or concurrently requested cancellation.
 `waitable-set.poll` (and other cancellable operations) will only indicate
@@ -3937,8 +3908,8 @@ def canon_waitable_set_drop(thread, i):
   return []
 ```
 Note that `WaitableSet.drop` will trap if it is non-empty or there is a
-concurrent `waitable-set.wait` or `waitable-set.poll` or `async callback`
-currently using this waitable set.
+concurrent `waitable-set.wait` or `async callback` currently using this
+waitable set.
 
 
 ### 🔀 `canon waitable.join`
@@ -4617,7 +4588,7 @@ def canon_thread_yield(cancellable, thread):
 If a non-`async`-typed function export that has not yet returned a value
 transitively calls `thread.yield`, it returns immediately without blocking
 (instead of trapping, as with other possibly-blocking operations like
-`waitable-set.poll`). This is because, unlike other built-ins, `thread.yield`
+`waitable-set.wait`). This is because, unlike other built-ins, `thread.yield`
 may be scattered liberally throughout code that might show up in the transitive
 call tree of a synchronous function call.
 

design/mvp/Concurrency.md

@@ -474,7 +474,7 @@ all of which are described above or below in more detail:
 * cooperatively yielding (e.g., during a long-running computation) via the
   [`thread.yield`](#thread-built-ins) built-in
 * waiting for one of a set of concurrent operations to complete via the
-  [`waitable-set.{wait,poll}`](#waitables-and-waitable-sets) built-ins
+  [`waitable-set.wait`](#waitables-and-waitable-sets) built-in
 * waiting for a stream or future operation to complete via the
   [`{stream,future}.{,cancel-}{read,write}`](#streams-and-futures) built-ins
 * waiting for a subtask to cooperatively cancel itself via the
@@ -509,9 +509,8 @@ Specifically, waitable sets are created and used via the following built-ins:
   waitable set
 * [`waitable-set.wait`]: suspend until one of the waitables in the given set
   has a pending event and then return that event
-* [`waitable-set.poll`]: first `thread.yield` and, once resumed, if any of the
-  waitables in the given set has a pending event, return that event; otherwise
-  return a sentinel "none" value
+* [`waitable-set.poll`]: if any of the waitables in the given set has a pending
+  event, return that event; otherwise return a sentinel "none" value
 
 In addition to subtasks, (the readable and writable ends of) [streams and
 futures](#streams-and-futures) are *also* waitables, which means that a single
@@ -813,7 +812,7 @@ defined by the Component Model:
   waitable's event is delivered first.
 * If multiple threads wait on or poll the same waitable set at the same time,
   the distribution of events to threads is nondeterministic.
-* Whenever a thread yields or waits on (or polls) a waitable set with an already
+* Whenever a thread yields or waits on a waitable set with an already
   pending event, whether the thread suspends and transfers execution to an
   async caller is nondeterministic.
 * If multiple threads that previously suspended can be resumed at the same
@@ -1054,8 +1053,6 @@ The `(result i32)` lets the core function return what it wants the runtime to do
   to run, but resuming thereafter without waiting on anything else.
 * If the low 4 bits are `2`, the callee wants to wait for an event to occur in
   the waitable set whose index is stored in the high 28 bits.
-* If the low 4 bits are `3`, the callee wants to poll for any events that have
-  occurred in the waitable set whose index is stored in the high 28 bits.
 
 When an async stackless function is exported, a companion "callback" function
 must also be exported with signature:

design/mvp/Explainer.md

@@ -1739,26 +1739,15 @@ For details, see [Waitables and Waitable Sets] in the concurrency explainer and
 
 where `event` is defined as in [`waitable-set.wait`](#-waitable-setwait).
 
-The `waitable-set.poll` built-in suspends the [current thread] in
-the "ready" state (like `thread.yield`). Once nondeterministically resumed,
-`waitable-set.poll` will return either an event from one of the waitables in
-`s` or, if there is none, the `none` `event`. Thus, repeatedly calling
-`waitable-set.poll` in a loop allows other tasks to execute.
+The `waitable-set.poll` built-in returns either an event from one of the
+waitables in `s` or, if there is none, the `none` `event`.
 
 If `cancellable` is set, `waitable-set.poll` may return `task-cancelled`
 (`6`) if the caller requests [cancellation] of the [current task]. If
 `cancellable` is not set, `task-cancelled` is never returned.
 `task-cancelled` is returned at most once for a given task and thus must be
 propagated once received.
 
-If `waitable-set.poll` is called from a synchronous- or `async callback`-lifted
-export, no other threads that were implicitly created by a separate
-synchronous- or `async callback`-lifted export call can start or progress in
-the current component instance until `waitable-set.poll` returns (thereby
-ensuring non-reentrance of the core wasm code). However, explicitly-created
-threads and threads implicitly created by non-`callback` `async`-lifted
-("stackful async") exports may start or progress at any time.
-
 The Canonical ABI of `waitable-set.poll` is the same as `waitable-set.wait`
 (with the `none` case indicated by returning `0`).
 

design/mvp/canonical-abi/definitions.py

@@ -651,20 +651,6 @@ def ready_and_has_event():
     wset.num_waiting -= 1
     return event
 
-  def poll_until(self, ready_func, thread, wset, cancellable) -> Optional[EventTuple]:
-    assert(thread in self.threads and thread.task is self)
-    wset.num_waiting += 1
-    match self.suspend_until(ready_func, thread, cancellable):
-      case SuspendResult.CANCELLED:
-        event = (EventCode.TASK_CANCELLED, 0, 0)
-      case SuspendResult.NOT_CANCELLED:
-        if wset.has_pending_event():
-          event = wset.get_pending_event()
-        else:
-          event = (EventCode.NONE, 0, 0)
-    wset.num_waiting -= 1
-    return event
-
   def yield_until(self, ready_func, thread, cancellable) -> EventTuple:
     assert(thread in self.threads and thread.task is self)
     match self.suspend_until(ready_func, thread, cancellable):
@@ -2047,11 +2033,8 @@ def thread_func(thread):
           wset = inst.table.get(si)
           trap_if(not isinstance(wset, WaitableSet))
           event = task.wait_until(lambda: not inst.exclusive, thread, wset, cancellable = True)
-        case CallbackCode.POLL:
-          trap_if(not task.may_block())
-          wset = inst.table.get(si)
-          trap_if(not isinstance(wset, WaitableSet))
-          event = task.poll_until(lambda: not inst.exclusive, thread, wset, cancellable = True)
+        case _:
+          trap()
       thread.in_event_loop = False
       inst.exclusive = True
       event_code, p1, p2 = event
@@ -2068,8 +2051,7 @@ class CallbackCode(IntEnum):
   EXIT = 0
   YIELD = 1
   WAIT = 2
-  POLL = 3
-  MAX = 3
+  MAX = 2
 
 def unpack_callback_result(packed):
   code = packed & 0xf
@@ -2283,10 +2265,14 @@ def unpack_event(mem, thread, ptr, e: EventTuple):
 
 def canon_waitable_set_poll(cancellable, mem, thread, si, ptr):
   trap_if(not thread.task.inst.may_leave)
-  trap_if(not thread.task.may_block())
   wset = thread.task.inst.table.get(si)
   trap_if(not isinstance(wset, WaitableSet))
-  event = thread.task.poll_until(lambda: True, thread, wset, cancellable)
+  if thread.task.deliver_pending_cancel(cancellable):
+    event = (EventCode.TASK_CANCELLED, 0, 0)
+  elif not wset.has_pending_event():
+    event = (EventCode.NONE, 0, 0)
+  else:
+    event = wset.get_pending_event()
   return unpack_event(mem, thread, ptr, event)
 
 ### 🔀 `canon waitable-set.drop`

design/mvp/canonical-abi/run_tests.py

@@ -1031,6 +1031,8 @@ def consumer(thread, args):
 
     remain = [subi1, subi2]
     while remain:
+      [ret] = canon_thread_yield(True, thread)
+      assert(ret == 0)
       retp = 8
       [event] = canon_waitable_set_poll(True, consumer_heap.memory, thread, seti, retp)
       if event == EventCode.NONE:

test/async/trap-if-block-and-sync.wast

@@ -75,13 +75,20 @@
           (i32.const 2 (; WAIT ;))
           (i32.shl (call $waitable-set.new) (i32.const 4)))
       )
-      (func (export "trap-if-poll")
-        (call $waitable-set.poll (call $waitable-set.new) (i32.const 0xdeadbeef))
-        unreachable
+      (func (export "poll-is-fine") (result i32)
+        (local $ret i32)
+        (local.set $ret (call $waitable-set.poll (call $waitable-set.new) (i32.const 0)))
+        (if (i32.ne (i32.const 0 (; NONE ;)) (local.get $ret))
+          (then unreachable))
+        (if (i32.ne (i32.const 0) (i32.load (i32.const 0)))
+          (then unreachable))
+        (if (i32.ne (i32.const 0) (i32.load (i32.const 4)))
+          (then unreachable))
+        (i32.const 42)
       )
-      (func (export "trap-if-poll-cb") (result i32)
+      (func (export "trap-if-invalid-callback-code") (param $invalid-code i32) (result i32)
         (i32.or
-          (i32.const 3 (; POLL ;))
+          (local.get $invalid-code)
           (i32.shl (call $waitable-set.new) (i32.const 4)))
       )
       (func (export "yield-is-fine") (result i32)
@@ -174,8 +181,8 @@
     (func (export "trap-if-suspend") (canon lift (core func $core "trap-if-suspend")))
     (func (export "trap-if-wait") (canon lift (core func $core "trap-if-wait")))
     (func (export "trap-if-wait-cb") (canon lift (core func $core "trap-if-wait-cb") async (callback (func $core "unreachable-cb"))))
-    (func (export "trap-if-poll") (canon lift (core func $core "trap-if-poll")))
-    (func (export "trap-if-poll-cb") (canon lift (core func $core "trap-if-poll-cb") async (callback (func $core "unreachable-cb"))))
+    (func (export "poll-is-fine") (result u32) (canon lift (core func $core "poll-is-fine")))
+    (func (export "trap-if-invalid-callback-code") (param "invalid-code" u32) (canon lift (core func $core "trap-if-invalid-callback-code") async (callback (func $core "unreachable-cb"))))
     (func (export "yield-is-fine") (result u32) (canon lift (core func $core "yield-is-fine")))
     (func (export "yield-is-fine-cb") (result u32) (canon lift (core func $core "yield-is-fine-cb") async (callback (func $core "return-42-cb"))))
     (func (export "trap-if-sync-call-async1") (canon lift (core func $core "trap-if-sync-call-async1")))
@@ -197,8 +204,8 @@
   (func (export "trap-if-suspend") (alias export $d "trap-if-suspend"))
   (func (export "trap-if-wait") (alias export $d "trap-if-wait"))
   (func (export "trap-if-wait-cb") (alias export $d "trap-if-wait-cb"))
-  (func (export "trap-if-poll") (alias export $d "trap-if-poll"))
-  (func (export "trap-if-poll-cb") (alias export $d "trap-if-poll-cb"))
+  (func (export "poll-is-fine") (alias export $d "poll-is-fine"))
+  (func (export "trap-if-invalid-callback-code") (alias export $d "trap-if-invalid-callback-code"))
   (func (export "yield-is-fine") (alias export $d "yield-is-fine"))
   (func (export "yield-is-fine-cb") (alias export $d "yield-is-fine-cb"))
   (func (export "trap-if-sync-cancel") (alias export $d "trap-if-sync-cancel"))
@@ -223,9 +230,13 @@
 (component instance $i $Tester)
 (assert_trap (invoke "trap-if-wait-cb") "cannot block a synchronous task before returning")
 (component instance $i $Tester)
-(assert_trap (invoke "trap-if-poll") "cannot block a synchronous task before returning")
+(assert_return (invoke "poll-is-fine") (u32.const 42))
+(component instance $i $Tester)
+(assert_trap (invoke "trap-if-invalid-callback-code" (u32.const 3)) "unsupported callback code: 3")
+(component instance $i $Tester)
+(assert_trap (invoke "trap-if-invalid-callback-code" (u32.const 4)) "unsupported callback code: 4")
 (component instance $i $Tester)
-(assert_trap (invoke "trap-if-poll-cb") "cannot block a synchronous task before returning")
+(assert_trap (invoke "trap-if-invalid-callback-code" (u32.const 15)) "unsupported callback code: 15")
 (component instance $i $Tester)
 (assert_return (invoke "yield-is-fine") (u32.const 42))
 (component instance $i $Tester)