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.rsindex 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 enabledfn 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.wastnew file mode 100644index 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"))