test: use wait/notify to improve threads.wat test

Previously, the test simply executed in a loop for some hardcoded number
of iterations. This changes uses `wait` and `notify` and atomic
operations to keep track of when the spawned threads are done and join
on the main thread appropriately.

Author: abrown

tests/all/cli_tests.rs

@@ -488,8 +488,13 @@ fn run_threads() -> Result<()> {
         wasm.path().to_str().unwrap(),
     ])?;
 
-    assert!(stdout.contains("Hello _start"));
-    assert!(stdout.contains("Hello wasi_thread_start"));
-    assert!(stdout.contains("Hello done"));
+    assert!(
+        stdout
+            == "Called _start\n\
+    Running wasi_thread_start\n\
+    Running wasi_thread_start\n\
+    Running wasi_thread_start\n\
+    Done\n"
+    );
     Ok(())
 }

tests/all/cli_tests/threads.wat

@@ -4,36 +4,42 @@
   (import "" "memory" (memory $shmem 1 1 shared))
   (import "wasi_snapshot_preview1" "fd_write"
     (func $__wasi_fd_write (param i32 i32 i32 i32) (result i32)))
+  (import "wasi_snapshot_preview1" "proc_exit"
+    (func $__wasi_proc_exit (param i32)))
   (import "wasi" "thread_spawn"
     (func $__wasi_thread_spawn (param i32) (result i32)))
 
   (func (export "_start")
     (local $i i32)
 
-    ;; Print "Hello _start".
-    (call $print (i32.const 32) (i32.const 13))
+    ;; Print "Called _start".
+    (call $print (i32.const 32) (i32.const 14))
 
-    ;; Print "Hello wasi_thread_start" in several threads.
+    ;; Print "Running wasi_thread_start" in several threads.
     (drop (call $__wasi_thread_spawn (i32.const 0)))
     (drop (call $__wasi_thread_spawn (i32.const 0)))
     (drop (call $__wasi_thread_spawn (i32.const 0)))
 
-    ;; Spin to allow the threads to do their work. TODO: replace this with
-    ;; a loop over `wait` with `notify` instructions in the
-    ;; `wasi_thread_start` entry point.
-    (local.set $i (i32.const 4000000))
+    ;; Wait for all the threads to notify us that they are done.
     (loop $again
-      (local.set $i (i32.sub (local.get $i) (i32.const 1)))
-      (br_if $again (i32.gt_s (local.get $i) (i32.const 0)))
+      ;; Retrieve the i32 at address 128, compare it to -1 (it should always
+      ;; fail) and load it atomically to check if all three threads are
+      ;; complete. This wait is for 1ms or until notified, whichever is first.
+      (drop (memory.atomic.wait32 (i32.const 128) (i32.const -1) (i64.const 1000000)))
+      (br_if $again (i32.lt_s (i32.atomic.load (i32.const 128)) (i32.const 3)))
     )
 
-    ;; Print "Hello done".
-    (call $print (i32.const 64) (i32.const 11))
+    ;; Print "Done".
+    (call $print (i32.const 64) (i32.const 5))
   )
 
   ;; A threads-enabled module must export this spec-designated entry point.
   (func (export "wasi_thread_start") (param $tid i32) (param $start_arg i32)
-    (call $print (i32.const 96) (i32.const 24))
+    (call $print (i32.const 96) (i32.const 26))
+    ;; After printing, we atomically increment the value at address 128 and then
+    ;; wake up the main thread's join loop.
+    (drop (i32.atomic.rmw.add (i32.const 128) (i32.const 1)))
+    (drop (memory.atomic.notify (i32.const 128) (i32.const 1)))
   )
 
   ;; A helper function for printing ptr-len strings.
@@ -50,7 +56,7 @@
   ;; We still need to export the shared memory for Wiggle's sake.
   (export "memory" (memory $shmem))
 
-  (data (i32.const 32) "Hello _start\0a")
-  (data (i32.const 64) "Hello done\0a")
-  (data (i32.const 96) "Hello wasi_thread_start\0a")
+  (data (i32.const 32) "Called _start\0a")
+  (data (i32.const 64) "Done\0a")
+  (data (i32.const 96) "Running wasi_thread_start\0a")
 )