Skip to content

A lightweight WebAssembly runtime that is fast, secure, and standards-compliant

Allow stackful tasks to enter instances at any time (#14905)

Alex Crichton1a9d6d2d4160
diff --git a/crates/wasmtime/src/runtime/component/concurrent.rs b/crates/wasmtime/src/runtime/component/concurrent.rs
index ed086431d2..863e1cf23e 100644
--- a/crates/wasmtime/src/runtime/component/concurrent.rs
+++ b/crates/wasmtime/src/runtime/component/concurrent.rs
@@ -786,20 +786,30 @@ impl GuestCall {
/// A call will not be ready to run if either:
///
/// - the (sub-)component instance to be called has already been entered and
- /// cannot be reentered until an in-progress call completes
+ /// cannot be reentered until an in-progress call completes, and the task
+ /// requires the exclusive lock
///
/// - the call is for a not-yet started task and the (sub-)component
- /// instance to be called has backpressure enabled
+ /// instance to be called has backpressure enabled
fn is_ready(&self, store: &mut StoreOpaque) -> Result<bool> {
let task = store.concurrent_state_mut()?.get_mut(self.thread.task)?;
let async_typed = task.async_typed;
+ let async_lifted = task.async_lifted;
+ let has_callback = task.callback.is_some();
let instance = task.instance;
let state = store.instance_state(instance).concurrent_state();
let ready = match &self.kind {
GuestCallKind::DeliverEvent { .. } => !state.do_not_enter,
GuestCallKind::StartImplicit(_) => {
- !async_typed || !(state.do_not_enter || state.backpressure > 0)
+ if async_typed {
+ // Sync- and callback-lifted exports need the instance's
+ // exclusive lock to start, but stackful ones don't.
+ let needs_exclusive = !async_lifted || has_callback;
+ !((needs_exclusive && state.do_not_enter) || state.backpressure > 0)
+ } else {
+ true
+ }
}
GuestCallKind::StartExplicit(_) => true,
};
diff --git a/tests/misc_testsuite/component-model/async/stackful-enter-while-locked.wast b/tests/misc_testsuite/component-model/async/stackful-enter-while-locked.wast
new file mode 100644
index 0000000000..f131c7a9ab
--- /dev/null
+++ b/tests/misc_testsuite/component-model/async/stackful-enter-while-locked.wast
@@ -0,0 +1,124 @@
+;;! component_model_async = true
+;;! component_model_async_stackful = true
+
+;; A callback-lifted task ($A.f) blocks inside its core function (in
+;; `waitable-set.wait`), so it holds $A's exclusive lock. Only sync- and
+;; callback-lifted tasks need that lock, so a stackful export ($A.g) can still
+;; start, and here it writes the future that $A.f is waiting on.
+(component
+ (component $A
+ (core module $libc (memory (export "mem") 1))
+ (core instance $libc (instantiate $libc))
+ (type $FT (future))
+ (core func $future.new (canon future.new $FT))
+ (core func $future.read (canon future.read $FT async (memory (core memory $libc "mem"))))
+ (core func $waitable-set.new (canon waitable-set.new))
+ (core func $waitable-set.wait (canon waitable-set.wait (memory (core memory $libc "mem"))))
+ (core func $waitable.join (canon waitable.join))
+ (core func $future.write (canon future.write $FT async (memory (core memory $libc "mem"))))
+ (core func $future.drop-readable (canon future.drop-readable $FT))
+ (core func $future.drop-writable (canon future.drop-writable $FT))
+ (core func $task.return (canon task.return))
+ (core module $m
+ (import "libc" "mem" (memory 1))
+ (import "" "future.new" (func $future.new (result i64)))
+ (import "" "future.read" (func $future.read (param i32 i32) (result i32)))
+ (import "" "future.write" (func $future.write (param i32 i32) (result i32)))
+ (import "" "future.drop-readable" (func $future.drop-readable (param i32)))
+ (import "" "future.drop-writable" (func $future.drop-writable (param i32)))
+ (import "" "task.return" (func $task.return))
+ (import "" "waitable-set.new" (func $waitable-set.new (result i32)))
+ (import "" "waitable-set.wait" (func $waitable-set.wait (param i32 i32) (result i32)))
+ (import "" "waitable.join" (func $waitable.join (param i32 i32)))
+ (global $w (mut i32) (i32.const 0))
+ (func (export "f") (result i32)
+ (local $fut i64) (local $r i32) (local $ws i32)
+ (local.set $fut (call $future.new))
+ (local.set $r (i32.wrap_i64 (local.get $fut)))
+ (global.set $w (i32.wrap_i64 (i64.shr_u (local.get $fut) (i64.const 32))))
+ ;; async read: BLOCKED
+ (if (i32.ne (call $future.read (local.get $r) (i32.const 0)) (i32.const -1))
+ (then unreachable))
+ ;; wait for it *inside the core function* (not by returning WAIT):
+ ;; blocks until $g writes (FUTURE_READ = 4, COMPLETED = 0)
+ (local.set $ws (call $waitable-set.new))
+ (call $waitable.join (local.get $r) (local.get $ws))
+ (if (i32.ne (call $waitable-set.wait (local.get $ws) (i32.const 0)) (i32.const 4))
+ (then unreachable))
+ (if (i32.ne (i32.load (i32.const 4)) (i32.const 0)) (then unreachable))
+ (call $waitable.join (local.get $r) (i32.const 0))
+ (call $future.drop-readable (local.get $r))
+ (call $task.return)
+ (i32.const 0 (; EXIT ;)))
+ (func (export "cb") (param i32 i32 i32) (result i32) unreachable)
+ (func (export "g")
+ ;; the reader is waiting, so even the async write completes eagerly
+ (if (i32.ne (call $future.write (global.get $w) (i32.const 0)) (i32.const 0))
+ (then unreachable))
+ (call $future.drop-writable (global.get $w))
+ (call $task.return)))
+ (core instance $i (instantiate $m
+ (with "libc" (instance $libc))
+ (with "" (instance
+ (export "future.new" (func $future.new))
+ (export "future.read" (func $future.read))
+ (export "future.write" (func $future.write))
+ (export "future.drop-readable" (func $future.drop-readable))
+ (export "future.drop-writable" (func $future.drop-writable))
+ (export "task.return" (func $task.return))
+ (export "waitable-set.new" (func $waitable-set.new))
+ (export "waitable-set.wait" (func $waitable-set.wait))
+ (export "waitable.join" (func $waitable.join))))))
+ (func (export "f") async (canon lift (core func $i "f") async (callback (core func $i "cb"))))
+ (func (export "g") async (canon lift (core func $i "g") async)))
+
+ (component $C
+ (import "f" (func $f async))
+ (import "g" (func $g async))
+ (core module $libc (memory (export "mem") 1))
+ (core instance $libc (instantiate $libc))
+ (core func $f (canon lower (func $f) async (memory (core memory $libc "mem"))))
+ (core func $g (canon lower (func $g) async (memory (core memory $libc "mem"))))
+ (core func $waitable-set.new (canon waitable-set.new))
+ (core func $waitable-set.wait (canon waitable-set.wait (memory (core memory $libc "mem"))))
+ (core func $waitable.join (canon waitable.join))
+ (core func $subtask.drop (canon subtask.drop))
+ (core func $task.return (canon task.return))
+ (core module $m
+ (import "" "f" (func $f (result i32)))
+ (import "" "g" (func $g (result i32)))
+ (import "" "waitable-set.new" (func $waitable-set.new (result i32)))
+ (import "" "waitable-set.wait" (func $waitable-set.wait (param i32 i32) (result i32)))
+ (import "" "waitable.join" (func $waitable.join (param i32 i32)))
+ (import "" "subtask.drop" (func $subtask.drop (param i32)))
+ (import "" "task.return" (func $task.return))
+ (func (export "run")
+ (local $ret i32) (local $sf i32) (local $ws i32)
+ ;; $A.f blocks: subtask 1, STARTED (1)
+ (local.set $ret (call $f))
+ (if (i32.ne (local.get $ret) (i32.const 0x11)) (then unreachable))
+ (local.set $sf (i32.shr_u (local.get $ret) (i32.const 4)))
+ ;; $A.g starts right away and returns: RETURNED (2)
+ (if (i32.ne (call $g) (i32.const 2)) (then unreachable))
+ ;; now $A.f can finish
+ (local.set $ws (call $waitable-set.new))
+ (call $waitable.join (local.get $sf) (local.get $ws))
+ (if (i32.ne (call $waitable-set.wait (local.get $ws) (i32.const 0)) (i32.const 1 (; SUBTASK ;)))
+ (then unreachable))
+ (call $subtask.drop (local.get $sf))
+ (call $task.return)))
+ (core instance $i (instantiate $m (with "" (instance
+ (export "f" (func $f))
+ (export "g" (func $g))
+ (export "waitable-set.new" (func $waitable-set.new))
+ (export "waitable-set.wait" (func $waitable-set.wait))
+ (export "waitable.join" (func $waitable.join))
+ (export "subtask.drop" (func $subtask.drop))
+ (export "task.return" (func $task.return))))))
+ (func (export "run") async (canon lift (core func $i "run") async)))
+
+ (instance $a (instantiate $A))
+ (instance $c (instantiate $C (with "f" (func $a "f")) (with "g" (func $a "g"))))
+ (export "run" (func $c "run")))
+
+(assert_return (invoke "run"))