A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
;;! component_model_async = true
;;! component_model_threading = true
;; `thread.{yield,suspend}-then-promote(T)` must switch to T immediately if T
;; is ready, per the spec's `Thread.ready`, regardless of how T became ready.
;; Each case below makes two threads ready, the promoted one second, and
;; records the order in which they run.
;; T2 was made ready with `thread.resume-later` but hasn't started yet.
(component
(core module $libc (table (export "t") 1 funcref))
(core instance $libc (instantiate $libc))
(core type $start-ty (func (param i32)))
(core func $thread.new-indirect (canon thread.new-indirect $start-ty (core table $libc "t")))
(core func $thread.resume-later (canon thread.resume-later))
(core func $thread.yield-then-promote (canon thread.yield-then-promote))
(core func $task.return (canon task.return (result u32)))
(core module $m
(import "" "thread.new-indirect" (func $thread.new-indirect (param i32 i32) (result i32)))
(import "" "thread.resume-later" (func $thread.resume-later (param i32)))
(import "" "thread.yield-then-promote" (func $thread.yield-then-promote (param i32) (result i32)))
(import "" "task.return" (func $task.return (param i32)))
(import "libc" "t" (table 1 funcref))
(global $g (mut i32) (i32.const 0))
(global $done (mut i32) (i32.const 0))
(func $f (param i32)
(global.set $g (i32.add (i32.mul (global.get $g) (i32.const 10)) (local.get 0)))
(global.set $done (i32.add (global.get $done) (i32.const 1))))
(elem (i32.const 0) func $f)
(func (export "run") (result i32)
(local $t1 i32) (local $t2 i32)
(local.set $t1 (call $thread.new-indirect (i32.const 0) (i32.const 1)))
(local.set $t2 (call $thread.new-indirect (i32.const 0) (i32.const 2)))
(call $thread.resume-later (local.get $t1))
(call $thread.resume-later (local.get $t2))
(drop (call $thread.yield-then-promote (local.get $t2)))
(i32.const 1 (; YIELD ;)))
(func (export "cb") (param i32 i32 i32) (result i32)
(if (i32.ne (global.get $done) (i32.const 2))
(then (return (i32.const 1 (; YIELD ;)))))
(call $task.return (global.get $g))
(i32.const 0 (; EXIT ;))))
(core instance $i (instantiate $m
(with "libc" (instance $libc))
(with "" (instance
(export "thread.new-indirect" (func $thread.new-indirect))
(export "thread.resume-later" (func $thread.resume-later))
(export "thread.yield-then-promote" (func $thread.yield-then-promote))
(export "task.return" (func $task.return))))))
(func (export "run") async (result u32)
(canon lift (core func $i "run") async (callback (core func $i "cb"))))
)
(assert_return (invoke "run") (u32.const 21))
;; T2 started, suspended itself, and was then made ready again with
;; `thread.resume-later`.
(component
(core module $libc (table (export "t") 2 funcref))
(core instance $libc (instantiate $libc))
(core type $start-ty (func (param i32)))
(core func $thread.new-indirect (canon thread.new-indirect $start-ty (core table $libc "t")))
(core func $thread.resume-later (canon thread.resume-later))
(core func $thread.yield-then-resume (canon thread.yield-then-resume))
(core func $thread.yield-then-promote (canon thread.yield-then-promote))
(core func $thread.suspend (canon thread.suspend))
(core func $task.return (canon task.return (result u32)))
(core module $m
(import "" "thread.new-indirect" (func $thread.new-indirect (param i32 i32) (result i32)))
(import "" "thread.resume-later" (func $thread.resume-later (param i32)))
(import "" "thread.yield-then-resume" (func $thread.yield-then-resume (param i32) (result i32)))
(import "" "thread.yield-then-promote" (func $thread.yield-then-promote (param i32) (result i32)))
(import "" "thread.suspend" (func $thread.suspend (result i32)))
(import "" "task.return" (func $task.return (param i32)))
(import "libc" "t" (table 2 funcref))
(global $g (mut i32) (i32.const 0))
(global $done (mut i32) (i32.const 0))
(func $log (param i32)
(global.set $g (i32.add (i32.mul (global.get $g) (i32.const 10)) (local.get 0)))
(global.set $done (i32.add (global.get $done) (i32.const 1))))
(func $f (param i32)
(call $log (local.get 0)))
(func $suspend-first (param i32)
(drop (call $thread.suspend))
(call $log (local.get 0)))
(elem (i32.const 0) func $f $suspend-first)
(func (export "run") (result i32)
(local $t1 i32) (local $t2 i32)
(local.set $t2 (call $thread.new-indirect (i32.const 1) (i32.const 2)))
;; let T2 run until it suspends itself
(drop (call $thread.yield-then-resume (local.get $t2)))
(local.set $t1 (call $thread.new-indirect (i32.const 0) (i32.const 1)))
(call $thread.resume-later (local.get $t1))
(call $thread.resume-later (local.get $t2))
(drop (call $thread.yield-then-promote (local.get $t2)))
(i32.const 1 (; YIELD ;)))
(func (export "cb") (param i32 i32 i32) (result i32)
(if (i32.ne (global.get $done) (i32.const 2))
(then (return (i32.const 1 (; YIELD ;)))))
(call $task.return (global.get $g))
(i32.const 0 (; EXIT ;))))
(core instance $i (instantiate $m
(with "libc" (instance $libc))
(with "" (instance
(export "thread.new-indirect" (func $thread.new-indirect))
(export "thread.resume-later" (func $thread.resume-later))
(export "thread.yield-then-resume" (func $thread.yield-then-resume))
(export "thread.yield-then-promote" (func $thread.yield-then-promote))
(export "thread.suspend" (func $thread.suspend))
(export "task.return" (func $task.return))))))
(func (export "run") async (result u32)
(canon lift (core func $i "run") async (callback (core func $i "cb"))))
)
(assert_return (invoke "run") (u32.const 21))
;; The promoted thread is the implicit thread of a callback-lifted task which
;; returned `WAIT` and whose event has since arrived. Explicit thread T1 is
;; blocked in `waitable-set.wait` and is woken up first, and then explicit
;; thread T3 wakes up the implicit thread and promotes it.
(component
(core module $libc
(table (export "t") 3 funcref)
(memory (export "m") 1))
(core instance $libc (instantiate $libc))
(core type $start-ty (func (param i32)))
(type $f (future))
(core func $future.new (canon future.new $f))
(core func $future.read (canon future.read $f async))
(core func $future.write (canon future.write $f async))
(core func $waitable-set.new (canon waitable-set.new))
(core func $waitable-set.wait (canon waitable-set.wait (memory (core memory $libc "m"))))
(core func $waitable.join (canon waitable.join))
(core func $thread.new-indirect (canon thread.new-indirect $start-ty (core table $libc "t")))
(core func $thread.resume-later (canon thread.resume-later))
(core func $thread.index (canon thread.index))
(core func $thread.yield-then-promote (canon thread.yield-then-promote))
(core func $task.return (canon task.return (result u32)))
(core module $m
(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 "" "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 "" "thread.new-indirect" (func $thread.new-indirect (param i32 i32) (result i32)))
(import "" "thread.resume-later" (func $thread.resume-later (param i32)))
(import "" "thread.index" (func $thread.index (result i32)))
(import "" "thread.yield-then-promote" (func $thread.yield-then-promote (param i32) (result i32)))
(import "" "task.return" (func $task.return (param i32)))
(import "libc" "t" (table 3 funcref))
(global $g (mut i32) (i32.const 0))
(global $done (mut i32) (i32.const 0))
(global $w1 (mut i32) (i32.const 0))
(global $w2 (mut i32) (i32.const 0))
(global $s1 (mut i32) (i32.const 0))
(global $main (mut i32) (i32.const 0))
(func $log (param i32)
(global.set $g (i32.add (i32.mul (global.get $g) (i32.const 10)) (local.get 0)))
(global.set $done (i32.add (global.get $done) (i32.const 1))))
;; start a read on a new future, joining it to `set` and returning the
;; writable end
(func $start-read (param $set i32) (result i32)
(local $tmp i64) (local $r i32)
(local.set $tmp (call $future.new))
(local.set $r (i32.wrap_i64 (local.get $tmp)))
(if (i32.ne (call $future.read (local.get $r) (i32.const 0)) (i32.const -1 (; BLOCKED ;)))
(then unreachable))
(call $waitable.join (local.get $r) (local.get $set))
(i32.wrap_i64 (i64.shr_u (local.get $tmp) (i64.const 32))))
(func $waiter (param i32)
(if (i32.ne (call $waitable-set.wait (global.get $s1) (i32.const 0)) (i32.const 4 (; FUTURE_READ ;)))
(then unreachable))
(call $log (local.get 0)))
(func $wake-both (param i32)
;; wake up T1 and then the implicit thread, and then promote the latter
(if (i32.ne (call $future.write (global.get $w1) (i32.const 0)) (i32.const 0 (; COMPLETED ;)))
(then unreachable))
(if (i32.ne (call $future.write (global.get $w2) (i32.const 0)) (i32.const 0 (; COMPLETED ;)))
(then unreachable))
(drop (call $thread.yield-then-promote (global.get $main))))
(elem (i32.const 0) func $waiter $wake-both)
(func (export "run") (result i32)
(local $s2 i32) (local $t1 i32) (local $t3 i32)
(global.set $main (call $thread.index))
(global.set $s1 (call $waitable-set.new))
(global.set $w1 (call $start-read (global.get $s1)))
(local.set $s2 (call $waitable-set.new))
(global.set $w2 (call $start-read (local.get $s2)))
(local.set $t1 (call $thread.new-indirect (i32.const 0) (i32.const 1)))
(local.set $t3 (call $thread.new-indirect (i32.const 1) (i32.const 0)))
(call $thread.resume-later (local.get $t1))
(call $thread.resume-later (local.get $t3))
(i32.or (i32.const 2 (; WAIT ;)) (i32.shl (local.get $s2) (i32.const 4))))
(func (export "cb") (param $event i32) (param i32 i32) (result i32)
(if (i32.eq (local.get $event) (i32.const 4 (; FUTURE_READ ;)))
(then (call $log (i32.const 2))))
(if (i32.ne (global.get $done) (i32.const 2))
(then (return (i32.const 1 (; YIELD ;)))))
(call $task.return (global.get $g))
(i32.const 0 (; EXIT ;))))
(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 "waitable-set.new" (func $waitable-set.new))
(export "waitable-set.wait" (func $waitable-set.wait))
(export "waitable.join" (func $waitable.join))
(export "thread.new-indirect" (func $thread.new-indirect))
(export "thread.resume-later" (func $thread.resume-later))
(export "thread.index" (func $thread.index))
(export "thread.yield-then-promote" (func $thread.yield-then-promote))
(export "task.return" (func $task.return))))))
(func (export "run") async (result u32)
(canon lift (core func $i "run") async (callback (core func $i "cb"))))
)
(assert_return (invoke "run") (u32.const 21))
;; The promoted thread T1 is a stackful explicit thread blocked in
;; `waitable-set.wait` whose event has arrived. T1 and T2 each wait on their
;; own future; both futures are written, T2's first, and then T1 is promoted.
;; The result is `100 * <promote's return value> + <run order>`, so this also
;; checks that a successful promotion returns 0.
(component
(core module $libc
(table (export "t") 1 funcref)
(memory (export "m") 1))
(core instance $libc (instantiate $libc))
(core type $start-ty (func (param i32)))
(type $f (future))
(core func $future.new (canon future.new $f))
(core func $future.read (canon future.read $f async))
(core func $future.write (canon future.write $f async))
(core func $waitable-set.new (canon waitable-set.new))
(core func $waitable-set.wait (canon waitable-set.wait (memory (core memory $libc "m"))))
(core func $waitable.join (canon waitable.join))
(core func $thread.new-indirect (canon thread.new-indirect $start-ty (core table $libc "t")))
(core func $thread.yield-then-resume (canon thread.yield-then-resume))
(core func $thread.yield-then-promote (canon thread.yield-then-promote))
(core func $task.return (canon task.return (result u32)))
(core module $m
(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 "" "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 "" "thread.new-indirect" (func $thread.new-indirect (param i32 i32) (result i32)))
(import "" "thread.yield-then-resume" (func $thread.yield-then-resume (param i32) (result i32)))
(import "" "thread.yield-then-promote" (func $thread.yield-then-promote (param i32) (result i32)))
(import "" "task.return" (func $task.return (param i32)))
(import "libc" "t" (table 1 funcref))
(global $g (mut i32) (i32.const 0))
(global $done (mut i32) (i32.const 0))
(global $s1 (mut i32) (i32.const 0))
(global $s2 (mut i32) (i32.const 0))
(global $ret (mut i32) (i32.const -1))
(func $log (param i32)
(global.set $g (i32.add (i32.mul (global.get $g) (i32.const 10)) (local.get 0)))
(global.set $done (i32.add (global.get $done) (i32.const 1))))
(func $start-read (param $set i32) (result i32)
(local $tmp i64) (local $r i32)
(local.set $tmp (call $future.new))
(local.set $r (i32.wrap_i64 (local.get $tmp)))
(if (i32.ne (call $future.read (local.get $r) (i32.const 0)) (i32.const -1))
(then unreachable))
(call $waitable.join (local.get $r) (local.get $set))
(i32.wrap_i64 (i64.shr_u (local.get $tmp) (i64.const 32))))
(func $waiter (param $n i32)
(if (i32.ne (call $waitable-set.wait
(select (global.get $s1) (global.get $s2) (i32.eq (local.get $n) (i32.const 1)))
(i32.const 0))
(i32.const 4))
(then unreachable))
(call $log (local.get $n)))
(elem (i32.const 0) func $waiter)
(func (export "run") (result i32)
(local $t1 i32) (local $t2 i32) (local $w1 i32) (local $w2 i32)
(global.set $s1 (call $waitable-set.new))
(global.set $s2 (call $waitable-set.new))
(local.set $w1 (call $start-read (global.get $s1)))
(local.set $w2 (call $start-read (global.get $s2)))
(local.set $t1 (call $thread.new-indirect (i32.const 0) (i32.const 1)))
(local.set $t2 (call $thread.new-indirect (i32.const 0) (i32.const 2)))
;; run each until it blocks in wait
(drop (call $thread.yield-then-resume (local.get $t1)))
(drop (call $thread.yield-then-resume (local.get $t2)))
(if (global.get $done) (then unreachable))
;; wake T2 first, then T1
(if (i32.ne (call $future.write (local.get $w2) (i32.const 0)) (i32.const 0)) (then unreachable))
(if (i32.ne (call $future.write (local.get $w1) (i32.const 0)) (i32.const 0)) (then unreachable))
(global.set $ret (call $thread.yield-then-promote (local.get $t1)))
(i32.const 1 (; YIELD ;)))
(func (export "cb") (param i32 i32 i32) (result i32)
(if (i32.ne (global.get $done) (i32.const 2))
(then (return (i32.const 1 (; YIELD ;)))))
(call $task.return (i32.add (i32.mul (global.get $ret) (i32.const 100)) (global.get $g)))
(i32.const 0 (; EXIT ;))))
(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 "waitable-set.new" (func $waitable-set.new))
(export "waitable-set.wait" (func $waitable-set.wait))
(export "waitable.join" (func $waitable.join))
(export "thread.new-indirect" (func $thread.new-indirect))
(export "thread.yield-then-resume" (func $thread.yield-then-resume))
(export "thread.yield-then-promote" (func $thread.yield-then-promote))
(export "task.return" (func $task.return))))))
(func (export "run") async (result u32)
(canon lift (core func $i "run") async (callback (core func $i "cb"))))
)
(assert_return (invoke "run") (u32.const 12))
;; Same as the previous case, but with `thread.suspend-then-promote`. The main
;; thread stays suspended until T1 resumes it with `thread.resume-later`.
(component
(core module $libc
(table (export "t") 1 funcref)
(memory (export "m") 1))
(core instance $libc (instantiate $libc))
(core type $start-ty (func (param i32)))
(type $f (future))
(core func $future.new (canon future.new $f))
(core func $future.read (canon future.read $f async))
(core func $future.write (canon future.write $f async))
(core func $waitable-set.new (canon waitable-set.new))
(core func $waitable-set.wait (canon waitable-set.wait (memory (core memory $libc "m"))))
(core func $waitable.join (canon waitable.join))
(core func $thread.new-indirect (canon thread.new-indirect $start-ty (core table $libc "t")))
(core func $thread.yield-then-resume (canon thread.yield-then-resume))
(core func $thread.suspend-then-promote (canon thread.suspend-then-promote))
(core func $task.return (canon task.return (result u32)))
(core func $thread.index (canon thread.index))
(core func $thread.resume-later (canon thread.resume-later))
(core module $m
(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 "" "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 "" "thread.new-indirect" (func $thread.new-indirect (param i32 i32) (result i32)))
(import "" "thread.yield-then-resume" (func $thread.yield-then-resume (param i32) (result i32)))
(import "" "thread.suspend-then-promote" (func $thread.suspend-then-promote (param i32) (result i32)))
(import "" "task.return" (func $task.return (param i32)))
(import "libc" "t" (table 1 funcref))
(import "" "thread.index" (func $thread.index (result i32)))
(import "" "thread.resume-later" (func $thread.resume-later (param i32)))
(global $main (mut i32) (i32.const 0))
(global $g (mut i32) (i32.const 0))
(global $done (mut i32) (i32.const 0))
(global $s1 (mut i32) (i32.const 0))
(global $s2 (mut i32) (i32.const 0))
(global $ret (mut i32) (i32.const -1))
(func $log (param i32)
(global.set $g (i32.add (i32.mul (global.get $g) (i32.const 10)) (local.get 0)))
(global.set $done (i32.add (global.get $done) (i32.const 1))))
(func $start-read (param $set i32) (result i32)
(local $tmp i64) (local $r i32)
(local.set $tmp (call $future.new))
(local.set $r (i32.wrap_i64 (local.get $tmp)))
(if (i32.ne (call $future.read (local.get $r) (i32.const 0)) (i32.const -1))
(then unreachable))
(call $waitable.join (local.get $r) (local.get $set))
(i32.wrap_i64 (i64.shr_u (local.get $tmp) (i64.const 32))))
(func $waiter (param $n i32)
(if (i32.ne (call $waitable-set.wait
(select (global.get $s1) (global.get $s2) (i32.eq (local.get $n) (i32.const 1)))
(i32.const 0))
(i32.const 4))
(then unreachable))
(call $log (local.get $n))
;; resume the suspended main thread
(if (i32.eq (local.get $n) (i32.const 1)) (then (call $thread.resume-later (global.get $main)))))
(elem (i32.const 0) func $waiter)
(func (export "run") (result i32)
(local $t1 i32) (local $t2 i32) (local $w1 i32) (local $w2 i32)
(global.set $main (call $thread.index))
(global.set $s1 (call $waitable-set.new))
(global.set $s2 (call $waitable-set.new))
(local.set $w1 (call $start-read (global.get $s1)))
(local.set $w2 (call $start-read (global.get $s2)))
(local.set $t1 (call $thread.new-indirect (i32.const 0) (i32.const 1)))
(local.set $t2 (call $thread.new-indirect (i32.const 0) (i32.const 2)))
;; run each until it blocks in wait
(drop (call $thread.yield-then-resume (local.get $t1)))
(drop (call $thread.yield-then-resume (local.get $t2)))
(if (global.get $done) (then unreachable))
;; wake T2 first, then T1
(if (i32.ne (call $future.write (local.get $w2) (i32.const 0)) (i32.const 0)) (then unreachable))
(if (i32.ne (call $future.write (local.get $w1) (i32.const 0)) (i32.const 0)) (then unreachable))
(global.set $ret (call $thread.suspend-then-promote (local.get $t1)))
(i32.const 1 (; YIELD ;)))
(func (export "cb") (param i32 i32 i32) (result i32)
(if (i32.ne (global.get $done) (i32.const 2))
(then (return (i32.const 1 (; YIELD ;)))))
(call $task.return (i32.add (i32.mul (global.get $ret) (i32.const 100)) (global.get $g)))
(i32.const 0 (; EXIT ;))))
(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 "waitable-set.new" (func $waitable-set.new))
(export "waitable-set.wait" (func $waitable-set.wait))
(export "waitable.join" (func $waitable.join))
(export "thread.new-indirect" (func $thread.new-indirect))
(export "thread.yield-then-resume" (func $thread.yield-then-resume))
(export "thread.suspend-then-promote" (func $thread.suspend-then-promote))
(export "task.return" (func $task.return))
(export "thread.index" (func $thread.index))
(export "thread.resume-later" (func $thread.resume-later))))))
(func (export "run") async (result u32)
(canon lift (core func $i "run") async (callback (core func $i "cb"))))
)
(assert_return (invoke "run") (u32.const 12))
;; The promoted thread is the implicit thread of a callback-lifted task which
;; returned `YIELD`. Explicit thread T1 is made ready first, and then explicit
;; thread T3 promotes the implicit thread, whose callback logs 2.
(component
(core module $libc (table (export "t") 2 funcref))
(core instance $libc (instantiate $libc))
(core type $start-ty (func (param i32)))
(core func $thread.new-indirect (canon thread.new-indirect $start-ty (core table $libc "t")))
(core func $thread.resume-later (canon thread.resume-later))
(core func $thread.yield-then-promote (canon thread.yield-then-promote))
(core func $thread.index (canon thread.index))
(core func $task.return (canon task.return (result u32)))
(core module $m
(import "" "thread.new-indirect" (func $thread.new-indirect (param i32 i32) (result i32)))
(import "" "thread.resume-later" (func $thread.resume-later (param i32)))
(import "" "thread.yield-then-promote" (func $thread.yield-then-promote (param i32) (result i32)))
(import "" "thread.index" (func $thread.index (result i32)))
(import "" "task.return" (func $task.return (param i32)))
(import "libc" "t" (table 2 funcref))
(global $g (mut i32) (i32.const 0))
(global $done (mut i32) (i32.const 0))
(global $main (mut i32) (i32.const 0))
(global $first (mut i32) (i32.const 1))
(func $log (param i32)
(global.set $g (i32.add (i32.mul (global.get $g) (i32.const 10)) (local.get 0)))
(global.set $done (i32.add (global.get $done) (i32.const 1))))
(func $f (param i32) (call $log (local.get 0)))
(func $promoter (param i32) (drop (call $thread.yield-then-promote (global.get $main))))
(elem (i32.const 0) func $f $promoter)
(func (export "run") (result i32)
(local $t1 i32) (local $t3 i32)
(global.set $main (call $thread.index))
(local.set $t1 (call $thread.new-indirect (i32.const 0) (i32.const 1)))
(local.set $t3 (call $thread.new-indirect (i32.const 1) (i32.const 0)))
(call $thread.resume-later (local.get $t3))
(call $thread.resume-later (local.get $t1))
(i32.const 1 (; YIELD ;)))
(func (export "cb") (param i32 i32 i32) (result i32)
(if (global.get $first) (then (global.set $first (i32.const 0)) (call $log (i32.const 2))))
(if (i32.ne (global.get $done) (i32.const 2))
(then (return (i32.const 1 (; YIELD ;)))))
(call $task.return (global.get $g))
(i32.const 0 (; EXIT ;))))
(core instance $i (instantiate $m
(with "libc" (instance $libc))
(with "" (instance
(export "thread.new-indirect" (func $thread.new-indirect))
(export "thread.resume-later" (func $thread.resume-later))
(export "thread.yield-then-promote" (func $thread.yield-then-promote))
(export "thread.index" (func $thread.index))
(export "task.return" (func $task.return))))))
(func (export "run") async (result u32)
(canon lift (core func $i "run") async (callback (core func $i "cb"))))
)
(assert_return (invoke "run") (u32.const 21))