Skip to content

Commit dd09215

Browse files
lukewagnerlukewagner
committed
Add some wast tests for async
1 parent 935c478 commit dd09215

8 files changed

Lines changed: 1210 additions & 0 deletions

File tree

‎test/concurrency/cancel-stream.wast‎

Lines changed: 203 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,203 @@
1+
;; This test contains two components $C and $D that test cancelling reads
2+
;; and writes in the presence and absence of partial reads/writes.
3+
;;
4+
;; $C exports a function 'start-stream' that creates and holds onto a writable
5+
;; stream in the global $sw as well as various operations that operate on $sw.
6+
;; $D calls $C.start-stream to get the readable end and then drives the test.
7+
(component
8+
(component $C
9+
(core module $Memory (memory (export "mem") 1))
10+
(core instance $memory (instantiate $Memory))
11+
(core module $CM
12+
(import "" "mem" (memory 1))
13+
(import "" "task.return" (func $task.return (param i32)))
14+
(import "" "stream.new" (func $stream.new (result i64)))
15+
(import "" "stream.write" (func $stream.write (param i32 i32 i32) (result i32)))
16+
(import "" "stream.cancel-write" (func $stream.cancel-write (param i32) (result i32)))
17+
(import "" "stream.close-writable" (func $stream.close-writable (param i32)))
18+
19+
(global $sw (mut i32) (i32.const 0))
20+
21+
(func $start-stream (export "start-stream") (result i32)
22+
;; create a new stream, return the readable end to the caller
23+
(local $ret64 i64)
24+
(local.set $ret64 (call $stream.new))
25+
(global.set $sw (i32.wrap_i64 (i64.shr_u (local.get $ret64) (i64.const 32))))
26+
(i32.wrap_i64 (local.get $ret64))
27+
)
28+
29+
(func $write4 (export "write4")
30+
;; write 6 bytes into the stream, expecting to rendezvous with a stream.read
31+
(local $ret i32)
32+
(i32.store (i32.const 8) (i32.const 0xabcd))
33+
(local.set $ret (call $stream.write (global.get $sw) (i32.const 8) (i32.const 4)))
34+
(if (i32.ne (i32.const 0x40 (; COMPLETED=0 | (4<<4) ;)) (local.get $ret))
35+
(then unreachable))
36+
)
37+
38+
(func $write4-and-close (export "write4-and-close")
39+
(call $write4)
40+
(call $stream.close-writable (global.get $sw))
41+
)
42+
43+
(func $start-blocking-write (export "start-blocking-write")
44+
(local $ret i32)
45+
46+
;; prepare the write buffer
47+
(i64.store (i32.const 8) (i64.const 0x123456789abcdef))
48+
49+
;; start one blocking write and immediately cancel it
50+
(local.set $ret (call $stream.write (global.get $sw) (i32.const 8) (i32.const 8)))
51+
(if (i32.ne (i32.const -1 (; BLOCKED ;)) (local.get $ret))
52+
(then unreachable))
53+
(local.set $ret (call $stream.cancel-write (global.get $sw)))
54+
(if (i32.ne (i32.const 0x2 (; CANCELLED ;)) (local.get $ret))
55+
(then unreachable))
56+
57+
;; start a second blockign write and leave it pending
58+
(local.set $ret (call $stream.write (global.get $sw) (i32.const 8) (i32.const 8)))
59+
(if (i32.ne (i32.const -1 (; BLOCKED ;)) (local.get $ret))
60+
(then unreachable))
61+
)
62+
63+
(func $cancel-after-read4 (export "cancel-after-read4")
64+
(local $ret i32)
65+
(local.set $ret (call $stream.cancel-write (global.get $sw)))
66+
(if (i32.ne (i32.const 0x42 (; TODO: CANCELLED=2 | (4<<4) ;)) (local.get $ret))
67+
(then unreachable))
68+
)
69+
)
70+
(type $ST (stream u8))
71+
(canon task.return (result u32) (core func $task.return))
72+
(canon stream.new $ST (core func $stream.new))
73+
(canon stream.write $ST async (memory $memory "mem") (core func $stream.write))
74+
(canon stream.cancel-write $ST (core func $stream.cancel-write))
75+
(canon stream.close-writable $ST (core func $stream.close-writable))
76+
(core instance $cm (instantiate $CM (with "" (instance
77+
(export "mem" (memory $memory "mem"))
78+
(export "task.return" (func $task.return))
79+
(export "stream.new" (func $stream.new))
80+
(export "stream.write" (func $stream.write))
81+
(export "stream.cancel-write" (func $stream.cancel-write))
82+
(export "stream.close-writable" (func $stream.close-writable))
83+
))))
84+
(func (export "start-stream") (result (stream u8)) (canon lift (core func $cm "start-stream")))
85+
(func (export "write4") (canon lift (core func $cm "write4")))
86+
(func (export "write4-and-close") (canon lift (core func $cm "write4-and-close")))
87+
(func (export "start-blocking-write") (canon lift (core func $cm "start-blocking-write")))
88+
(func (export "cancel-after-read4") (canon lift (core func $cm "cancel-after-read4")))
89+
)
90+
91+
(component $D
92+
(import "c" (instance $c
93+
(export "start-stream" (func (result (stream u8))))
94+
(export "write4" (func))
95+
(export "write4-and-close" (func))
96+
(export "start-blocking-write" (func))
97+
(export "cancel-after-read4" (func))
98+
))
99+
100+
(core module $Memory (memory (export "mem") 1))
101+
(core instance $memory (instantiate $Memory))
102+
(core module $DM
103+
(import "" "mem" (memory 1))
104+
(import "" "stream.read" (func $stream.read (param i32 i32 i32) (result i32)))
105+
(import "" "stream.cancel-read" (func $stream.cancel-read (param i32) (result i32)))
106+
(import "" "stream.close-readable" (func $stream.close-readable (param i32)))
107+
(import "" "start-stream" (func $start-stream (result i32)))
108+
(import "" "write4" (func $write4))
109+
(import "" "write4-and-close" (func $write4-and-close))
110+
(import "" "start-blocking-write" (func $start-blocking-write))
111+
(import "" "cancel-after-read4" (func $cancel-after-read4))
112+
113+
(func $run (export "run") (result i32)
114+
(local $ret i32)
115+
(local $sr i32)
116+
117+
;; call 'start-stream' to get the stream we'll be working with
118+
(local.set $sr (call $start-stream))
119+
(if (i32.ne (i32.const 1) (local.get $sr))
120+
(then unreachable))
121+
122+
;; start read that will block
123+
(local.set $ret (call $stream.read (local.get $sr) (i32.const 8) (i32.const 100)))
124+
(if (i32.ne (i32.const -1 (; BLOCKED;)) (local.get $ret))
125+
(then unreachable))
126+
127+
;; cancelling it will finish without anything having been written
128+
(local.set $ret (call $stream.cancel-read (local.get $sr)))
129+
(if (i32.ne (i32.const 0x2 (; CANCELLED ;)) (local.get $ret))
130+
(then unreachable))
131+
132+
;; read, block, call $C to write 4 bytes into the buffer,
133+
;; then cancel, which should show "4+cancelled"
134+
(local.set $ret (call $stream.read (local.get $sr) (i32.const 8) (i32.const 100)))
135+
(if (i32.ne (i32.const -1 (; BLOCKED;)) (local.get $ret))
136+
(then unreachable))
137+
(call $write4)
138+
(local.set $ret (call $stream.cancel-read (local.get $sr)))
139+
(if (i32.ne (i32.const 0x42 (; TODO: CANCELLED=2 | (4<<4) ;)) (local.get $ret))
140+
(then unreachable))
141+
(if (i32.ne (i32.const 0xabcd) (i32.load (i32.const 8)))
142+
(then unreachable))
143+
144+
;; read, block, call $C to write 4 bytes into the buffer and close,
145+
;; then cancel, which should show "4+closed"
146+
(local.set $ret (call $stream.read (local.get $sr) (i32.const 8) (i32.const 100)))
147+
(if (i32.ne (i32.const -1 (; BLOCKED;)) (local.get $ret))
148+
(then unreachable))
149+
(call $write4-and-close)
150+
(local.set $ret (call $stream.cancel-read (local.get $sr)))
151+
(if (i32.ne (i32.const 0x41 (; TODO: CANCELLED=2 | (4<<4) ;)) (local.get $ret))
152+
(then unreachable))
153+
(if (i32.ne (i32.const 0xabcd) (i32.load (i32.const 8)))
154+
(then unreachable))
155+
(call $stream.close-readable (local.get $sr))
156+
157+
;; get a new $sr
158+
(local.set $sr (call $start-stream))
159+
(if (i32.ne (i32.const 1) (local.get $sr))
160+
(then unreachable))
161+
162+
;; start outstanding write in $C, read 4 of it, then call back into $C
163+
;; which will cancel and see 4 written.
164+
(call $start-blocking-write)
165+
(local.set $ret (call $stream.read (local.get $sr) (i32.const 8) (i32.const 4)))
166+
(if (i32.ne (i32.const 0x40 (; COMPLETED=0 | (4<<4) ;)) (local.get $ret))
167+
(then unreachable))
168+
(if (i32.ne (i32.const 0x89abcdef) (i32.load (i32.const 8)))
169+
(then unreachable))
170+
(call $cancel-after-read4)
171+
172+
;; return 42 to the top-level assert_return
173+
(i32.const 42)
174+
)
175+
)
176+
(type $ST (stream u8))
177+
(canon stream.read $ST async (memory $memory "mem") (core func $stream.read))
178+
(canon stream.cancel-read $ST (core func $stream.cancel-read))
179+
(canon stream.close-readable $ST (core func $stream.close-readable))
180+
(canon lower (func $c "start-stream") (core func $start-stream'))
181+
(canon lower (func $c "write4") (core func $write4'))
182+
(canon lower (func $c "write4-and-close") (core func $write4-and-close'))
183+
(canon lower (func $c "start-blocking-write") (core func $start-blocking-write'))
184+
(canon lower (func $c "cancel-after-read4") (core func $cancel-after-read4'))
185+
(core instance $dm (instantiate $DM (with "" (instance
186+
(export "mem" (memory $memory "mem"))
187+
(export "stream.read" (func $stream.read))
188+
(export "stream.cancel-read" (func $stream.cancel-read))
189+
(export "stream.close-readable" (func $stream.close-readable))
190+
(export "start-stream" (func $start-stream'))
191+
(export "write4" (func $write4'))
192+
(export "write4-and-close" (func $write4-and-close'))
193+
(export "start-blocking-write" (func $start-blocking-write'))
194+
(export "cancel-after-read4" (func $cancel-after-read4'))
195+
))))
196+
(func (export "run") (result u32) (canon lift (core func $dm "run")))
197+
)
198+
199+
(instance $c (instantiate $C))
200+
(instance $d (instantiate $D (with "c" (instance $c))))
201+
(func (export "run") (alias export $d "run"))
202+
)
203+
(assert_return (invoke "run") (u32.const 42))

‎test/concurrency/cancel-subtask.wast‎

Lines changed: 117 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,117 @@
1+
;; This test contains two components $C and $D where $D imports and calls $C.
2+
;; $D.run calls $C.f, which blocks on an empty waitable set
3+
;; $D.run then subtask.cancels $C.f, which resumes $C.f which promptly resolves
4+
;; without returning a value.
5+
(component
6+
(component $C
7+
(core module $Memory (memory (export "mem") 1))
8+
(core instance $memory (instantiate $Memory))
9+
(core module $CM
10+
(import "" "mem" (memory 1))
11+
(import "" "task.cancel" (func $task.cancel))
12+
(import "" "waitable.join" (func $waitable.join (param i32 i32)))
13+
(import "" "waitable-set.new" (func $waitable-set.new (result i32)))
14+
(import "" "waitable-set.wait" (func $waitable-set.wait (param i32 i32) (result i32)))
15+
16+
;; $ws is waited on by 'f'
17+
(global $ws (mut i32) (i32.const 0))
18+
(func $start (global.set $ws (call $waitable-set.new)))
19+
(start $start)
20+
21+
(func $f (export "f") (result i32)
22+
;; wait on $ws which is currently empty, expected to get cancelled
23+
(i32.or (i32.const 2 (; WAIT ;)) (i32.shl (global.get $ws) (i32.const 4)))
24+
)
25+
(func $f_cb (export "f_cb") (param $event_code i32) (param $index i32) (param $payload i32) (result i32)
26+
;; confirm that we've received a cancellation request
27+
(if (i32.ne (local.get $event_code) (i32.const 6 (; TASK_CANCELLED ;)))
28+
(then unreachable))
29+
(if (i32.ne (local.get $index) (i32.const 0))
30+
(then unreachable))
31+
(if (i32.ne (local.get $payload) (i32.const 0))
32+
(then unreachable))
33+
34+
;; finish without returning a value
35+
(call $task.cancel)
36+
(i32.const 0 (; EXIT ;))
37+
)
38+
)
39+
(type $FT (future))
40+
(canon task.cancel (core func $task.cancel))
41+
(canon waitable.join (core func $waitable.join))
42+
(canon waitable-set.new (core func $waitable-set.new))
43+
(canon waitable-set.wait (memory $memory "mem") (core func $waitable-set.wait))
44+
(canon future.new $FT (core func $future.new))
45+
(canon future.read $FT async (memory $memory "mem") (core func $future.read))
46+
(canon future.write $FT async (memory $memory "mem") (core func $future.write))
47+
(canon future.close-readable $FT (core func $future.close-readable))
48+
(canon future.close-writable $FT (core func $future.close-writable))
49+
(core instance $cm (instantiate $CM (with "" (instance
50+
(export "mem" (memory $memory "mem"))
51+
(export "task.cancel" (func $task.cancel))
52+
(export "waitable.join" (func $waitable.join))
53+
(export "waitable-set.new" (func $waitable-set.new))
54+
(export "waitable-set.wait" (func $waitable-set.wait))
55+
(export "future.new" (func $future.new))
56+
(export "future.read" (func $future.read))
57+
(export "future.write" (func $future.write))
58+
(export "future.close-readable" (func $future.close-readable))
59+
(export "future.close-writable" (func $future.close-writable))
60+
))))
61+
(func (export "f") (result u32) (canon lift
62+
(core func $cm "f")
63+
async (callback (func $cm "f_cb"))
64+
))
65+
)
66+
67+
(component $D
68+
(import "f" (func $f (result u32)))
69+
70+
(core module $Memory (memory (export "mem") 1))
71+
(core instance $memory (instantiate $Memory))
72+
(core module $DM
73+
(import "" "mem" (memory 1))
74+
(import "" "subtask.cancel" (func $subtask.cancel (param i32) (result i32)))
75+
(import "" "f" (func $f (param i32 i32) (result i32)))
76+
77+
(func $run (export "run") (result i32)
78+
(local $ret i32) (local $retp i32)
79+
(local $subtask i32)
80+
(local $event_code i32)
81+
82+
;; call 'f'; it should block
83+
(local.set $retp (i32.const 4))
84+
(i32.store (local.get $retp) (i32.const 0xbad0bad0))
85+
(local.set $ret (call $f (i32.const 0xdeadbeef) (local.get $retp)))
86+
(if (i32.ne (i32.const 1 (; STARTING ;)) (i32.and (local.get $ret) (i32.const 0xf)))
87+
(then unreachable))
88+
(local.set $subtask (i32.shr_u (local.get $ret) (i32.const 4)))
89+
90+
;; cancel 'f'; it should complete without blocking
91+
(local.set $ret (call $subtask.cancel (local.get $subtask)))
92+
(if (i32.ne (i32.const 4 (; CANCELLED_BEFORE_RETURNED ;)) (local.get $ret))
93+
(then unreachable))
94+
95+
;; The $retp memory shouldn't have changed
96+
(if (i32.ne (i32.load (local.get $retp)) (i32.const 0xbad0bad0))
97+
(then unreachable))
98+
99+
;; return to the top-level assert_return
100+
(i32.const 42)
101+
)
102+
)
103+
(canon subtask.cancel (core func $subtask.cancel))
104+
(canon lower (func $f) async (memory $memory "mem") (core func $f'))
105+
(core instance $dm (instantiate $DM (with "" (instance
106+
(export "mem" (memory $memory "mem"))
107+
(export "subtask.cancel" (func $subtask.cancel))
108+
(export "f" (func $f'))
109+
))))
110+
(func (export "run") (result u32) (canon lift (core func $dm "run")))
111+
)
112+
113+
(instance $c (instantiate $C))
114+
(instance $d (instantiate $D (with "f" (func $c "f"))))
115+
(func (export "run") (alias export $d "run"))
116+
)
117+
(assert_return (invoke "run") (u32.const 42))

‎test/concurrency/deadlock.wast‎

Lines changed: 73 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,73 @@
1+
;; This test defines components $C and $D where $D imports and calls $C
2+
;; $C.f waits on an empty waitable set
3+
;; $D.g calls $C.f and then waits for it to finish, which fails due to deadlock
4+
(component
5+
(component $C
6+
(core module $Memory (memory (export "mem") 1))
7+
(core instance $memory (instantiate $Memory))
8+
(core module $CM
9+
(import "" "mem" (memory 1))
10+
(import "" "waitable-set.new" (func $waitable-set.new (result i32)))
11+
12+
(func (export "f") (result i32)
13+
;; wait on a new empty waitable set
14+
(local $ws i32)
15+
(local.set $ws (call $waitable-set.new))
16+
(i32.or (i32.const 2 (; WAIT ;)) (i32.shl (local.get $ws) (i32.const 4)))
17+
)
18+
(func (export "cb") (param $event_code i32) (param $index i32) (param $payload i32) (result i32)
19+
unreachable
20+
)
21+
)
22+
(canon waitable-set.new (core func $waitable-set.new))
23+
(core instance $cm (instantiate $CM (with "" (instance
24+
(export "mem" (memory $memory "mem"))
25+
(export "waitable-set.new" (func $waitable-set.new))
26+
))))
27+
(func (export "f") (result u32) (canon lift
28+
(core func $cm "f")
29+
async (memory $memory "mem") (callback (func $cm "cb"))
30+
))
31+
)
32+
33+
(component $D
34+
(import "f" (func $f (result u32)))
35+
36+
(core module $Memory (memory (export "mem") 1))
37+
(core instance $memory (instantiate $Memory))
38+
(core module $DM
39+
(import "" "mem" (memory 1))
40+
(import "" "waitable.join" (func $waitable.join (param i32 i32)))
41+
(import "" "waitable-set.new" (func $waitable-set.new (result i32)))
42+
(import "" "waitable-set.wait" (func $waitable-set.wait (param i32 i32) (result i32)))
43+
(import "" "f" (func $f (param i32 i32) (result i32)))
44+
45+
(func (export "g") (result i32)
46+
(local $ws i32) (local $ret i32) (local $subtaski i32)
47+
(local.set $ret (call $f (i32.const 0) (i32.const 0)))
48+
(local.set $subtaski (i32.shr_u (local.get $ret) (i32.const 4)))
49+
(local.set $ws (call $waitable-set.new))
50+
(call $waitable.join (local.get $subtaski) (local.get $ws))
51+
(call $waitable-set.wait (local.get $ws) (i32.const 0))
52+
unreachable
53+
)
54+
)
55+
(canon waitable.join (core func $waitable.join))
56+
(canon waitable-set.new (core func $waitable-set.new))
57+
(canon waitable-set.wait (memory $memory "mem") (core func $waitable-set.wait))
58+
(canon lower (func $f) async (memory $memory "mem") (core func $f'))
59+
(core instance $dm (instantiate $DM (with "" (instance
60+
(export "mem" (memory $memory "mem"))
61+
(export "waitable.join" (func $waitable.join))
62+
(export "waitable-set.new" (func $waitable-set.new))
63+
(export "waitable-set.wait" (func $waitable-set.wait))
64+
(export "f" (func $f'))
65+
))))
66+
(func (export "f") (result u32) (canon lift (core func $dm "g")))
67+
)
68+
69+
(instance $c (instantiate $C))
70+
(instance $d (instantiate $D (with "f" (func $c "f"))))
71+
(func (export "f") (alias export $d "f"))
72+
)
73+
(assert_trap (invoke "f") "wasm trap: deadlock detected: event loop cannot make further progress")

0 commit comments

Comments
 (0)