Skip to content

Commit bfeeb62

Browse files
eloparcoeloparco
committed
test(wasi-threads): add tests for wasi threads
1 parent 739acfc commit bfeeb62

8 files changed

Lines changed: 471 additions & 1 deletion

File tree

‎core/iwasm/libraries/wasi-threads/test/build.sh‎

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
#!/bin/bash
2+
3+
CC=${CC:=/opt/wasi-sdk/bin/clang}
4+
WASI_SYSROOT=${WASI_SYSROOT:=~/dev/wasi-libc/sysroot}
5+
WAMR_DIR=../../../../..
6+
7+
for test_c in *.c; do
8+
test_wasm="$(basename $test_c .c).wasm"
9+
10+
echo "Compiling $test_c to $test_wasm"
11+
$CC \
12+
--sysroot $WASI_SYSROOT \
13+
-target wasm32-wasi-threads \
14+
-pthread -ftls-model=local-exec \
15+
-z stack-size=32768 \
16+
-Wl,--export=__heap_base \
17+
-Wl,--export=__data_end \
18+
-Wl,--shared-memory,--max-memory=1966080 \
19+
-Wl,--export=wasi_thread_start \
20+
-Wl,--export=malloc \
21+
-Wl,--export=free \
22+
-I $WAMR_DIR/samples/wasi-threads/wasm-apps \
23+
$WAMR_DIR/samples/wasi-threads/wasm-apps/wasi_thread_start.S \
24+
$test_c -o $test_wasm
25+
done

‎core/iwasm/libraries/wasi-threads/test/create_threads_until_limit.c‎

Lines changed: 128 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,128 @@
1+
/*
2+
* Copyright (C) 2023 Amazon.com Inc. or its affiliates. All rights reserved.
3+
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
4+
*/
5+
6+
#ifndef __wasi__
7+
#error This example only compiles to WASM/WASI target
8+
#endif
9+
10+
#include <stdlib.h>
11+
#include <stdio.h>
12+
#include <assert.h>
13+
#include <stdbool.h>
14+
15+
#include "wasi_thread_start.h"
16+
17+
enum CONSTANTS {
18+
MAX_NUM_THREADS = 4, /* Should be the same as "--max-threads" */
19+
NUM_RETRY = 5,
20+
SECOND = 1000 * 1000 * 1000, /* 1 second */
21+
TIMEOUT = 10LL * SECOND
22+
};
23+
24+
int g_count = 0;
25+
26+
typedef struct {
27+
start_args_t base;
28+
int th_ready;
29+
int th_continue;
30+
int th_done;
31+
bool no_ops;
32+
} shared_t;
33+
34+
void
35+
__wasi_thread_start_C(int thread_id, int *start_arg)
36+
{
37+
shared_t *data = (shared_t *)start_arg;
38+
39+
if (data->no_ops) {
40+
__builtin_wasm_memory_atomic_wait32(NULL, 0, 2 * SECOND);
41+
return;
42+
}
43+
44+
__atomic_store_n(&data->th_ready, 1, __ATOMIC_SEQ_CST);
45+
__builtin_wasm_memory_atomic_notify(&data->th_ready, 1);
46+
47+
if (__builtin_wasm_memory_atomic_wait32(&data->th_continue, 0, TIMEOUT)
48+
== 2) {
49+
assert(false && "Wait should not time out");
50+
}
51+
52+
__atomic_fetch_add(&g_count, 1, __ATOMIC_SEQ_CST);
53+
54+
__atomic_store_n(&data->th_done, 1, __ATOMIC_SEQ_CST);
55+
__builtin_wasm_memory_atomic_notify(&data->th_done, 1);
56+
}
57+
58+
int
59+
main(int argc, char **argv)
60+
{
61+
shared_t data[MAX_NUM_THREADS] = { 0 };
62+
int thread_ids[MAX_NUM_THREADS];
63+
64+
for (int i = 0; i < MAX_NUM_THREADS; i++) {
65+
assert(start_args_init(&data[i].base));
66+
thread_ids[i] = __wasi_thread_spawn(&data[i]);
67+
printf("Thread created with id=%d\n", thread_ids[i]);
68+
assert(thread_ids[i] > 0 && "Thread creation failed");
69+
70+
for (int j = 0; j < i; j++) {
71+
assert(thread_ids[i] != thread_ids[j] && "Duplicated TIDs");
72+
}
73+
74+
if (__builtin_wasm_memory_atomic_wait32(&data[i].th_ready, 0, TIMEOUT)
75+
== 2) {
76+
assert(false && "Wait should not time out");
77+
}
78+
}
79+
80+
printf("Attempt to create thread when not possible\n");
81+
shared_t data_fail = { 0 };
82+
assert(start_args_init(&data_fail.base));
83+
int thread_id = __wasi_thread_spawn(&data_fail);
84+
start_args_deinit(&data_fail.base);
85+
assert(thread_id < 0 && "Thread creation should fail");
86+
87+
printf("Unlock created threads\n");
88+
for (int i = 0; i < MAX_NUM_THREADS; i++) {
89+
__atomic_store_n(&data[i].th_continue, 1, __ATOMIC_SEQ_CST);
90+
__builtin_wasm_memory_atomic_notify(&data[i].th_continue, 1);
91+
}
92+
93+
printf("Wait for threads to finish\n");
94+
for (int i = 0; i < MAX_NUM_THREADS; i++) {
95+
if (__builtin_wasm_memory_atomic_wait32(&data[i].th_done, 0, TIMEOUT)
96+
== 2) {
97+
assert(false && "Wait should not time out");
98+
}
99+
100+
start_args_deinit(&data[i].base);
101+
}
102+
103+
printf("Value of count after update: %d\n", g_count);
104+
assert(g_count == (MAX_NUM_THREADS)
105+
&& "Global count not updated correctly");
106+
107+
/* --------------------------------------------------- */
108+
109+
printf("Create new threads without waiting from them to finish\n");
110+
shared_t data_no_join[MAX_NUM_THREADS] = { 0 };
111+
for (int i = 0; i < MAX_NUM_THREADS; i++) {
112+
/* No graceful memory free to simplify the test */
113+
assert(start_args_init(&data_no_join[i].base));
114+
data_no_join[i].no_ops = true;
115+
116+
int thread_id = -1;
117+
for (int j = 0; j < NUM_RETRY && thread_id < 0; j++) {
118+
thread_id = __wasi_thread_spawn(&data_no_join[i]);
119+
if (thread_id < 0)
120+
__builtin_wasm_memory_atomic_wait32(NULL, 0, SECOND);
121+
}
122+
123+
printf("Thread created with id=%d\n", thread_id);
124+
assert(thread_id > 0 && "Thread creation should succeed");
125+
}
126+
127+
return EXIT_SUCCESS;
128+
}

‎core/iwasm/libraries/wasi-threads/test/global_atomic.c‎

Lines changed: 70 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,70 @@
1+
/*
2+
* Copyright (C) 2023 Amazon.com Inc. or its affiliates. All rights reserved.
3+
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
4+
*/
5+
6+
#ifndef __wasi__
7+
#error This example only compiles to WASM/WASI target
8+
#endif
9+
10+
#include <stdlib.h>
11+
#include <stdio.h>
12+
#include <assert.h>
13+
#include <stdbool.h>
14+
15+
#include "wasi_thread_start.h"
16+
17+
enum CONSTANTS {
18+
NUM_THREADS = 5,
19+
NUM_ITER = 1000,
20+
SECOND = 1000 * 1000 * 1000, /* 1 second */
21+
TIMEOUT = 10LL * SECOND
22+
};
23+
24+
int g_count = 0;
25+
26+
typedef struct {
27+
start_args_t base;
28+
int th_done;
29+
} shared_t;
30+
31+
void
32+
__wasi_thread_start_C(int thread_id, int *start_arg)
33+
{
34+
shared_t *data = (shared_t *)start_arg;
35+
36+
for (int i = 0; i < NUM_ITER; i++)
37+
__atomic_fetch_add(&g_count, 1, __ATOMIC_SEQ_CST);
38+
39+
__atomic_store_n(&data->th_done, 1, __ATOMIC_SEQ_CST);
40+
__builtin_wasm_memory_atomic_notify(&data->th_done, 1);
41+
}
42+
43+
int
44+
main(int argc, char **argv)
45+
{
46+
shared_t data[NUM_THREADS] = { 0 };
47+
int thread_ids[NUM_THREADS];
48+
49+
for (int i = 0; i < NUM_THREADS; i++) {
50+
assert(start_args_init(&data[i].base));
51+
thread_ids[i] = __wasi_thread_spawn(&data[i]);
52+
assert(thread_ids[i] > 0 && "Thread creation failed");
53+
}
54+
55+
printf("Wait for threads to finish\n");
56+
for (int i = 0; i < NUM_THREADS; i++) {
57+
if (__builtin_wasm_memory_atomic_wait32(&data[i].th_done, 0, TIMEOUT)
58+
== 2) {
59+
assert(false && "Wait should not time out");
60+
}
61+
62+
start_args_deinit(&data[i].base);
63+
}
64+
65+
printf("Value of count after update: %d\n", g_count);
66+
assert(g_count == (NUM_THREADS * NUM_ITER)
67+
&& "Global count not updated correctly");
68+
69+
return EXIT_SUCCESS;
70+
}

‎core/iwasm/libraries/wasi-threads/test/global_lock.c‎

Lines changed: 85 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,85 @@
1+
/*
2+
* Copyright (C) 2023 Amazon.com Inc. or its affiliates. All rights reserved.
3+
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
4+
*/
5+
6+
#ifndef __wasi__
7+
#error This example only compiles to WASM/WASI target
8+
#endif
9+
10+
#include <stdlib.h>
11+
#include <stdio.h>
12+
#include <assert.h>
13+
#include <stdbool.h>
14+
#include <pthread.h>
15+
16+
#include "wasi_thread_start.h"
17+
18+
enum CONSTANTS {
19+
NUM_THREADS = 4,
20+
NUM_ITER = 200,
21+
SECOND = 1000 * 1000 * 1000, /* 1 second */
22+
TIMEOUT = 10LL * SECOND
23+
};
24+
25+
pthread_mutex_t mutex;
26+
int g_count = 0;
27+
28+
typedef struct {
29+
start_args_t base;
30+
int th_done;
31+
} shared_t;
32+
33+
void
34+
__wasi_thread_start_C(int thread_id, int *start_arg)
35+
{
36+
shared_t *data = (shared_t *)start_arg;
37+
38+
for (int i = 0; i < NUM_ITER; i++) {
39+
pthread_mutex_lock(&mutex);
40+
g_count++;
41+
pthread_mutex_unlock(&mutex);
42+
}
43+
44+
__atomic_store_n(&data->th_done, 1, __ATOMIC_SEQ_CST);
45+
__builtin_wasm_memory_atomic_notify(&data->th_done, 1);
46+
}
47+
48+
int
49+
main(int argc, char **argv)
50+
{
51+
shared_t data[NUM_THREADS] = { 0 };
52+
int thread_ids[NUM_THREADS];
53+
54+
if (pthread_mutex_init(&mutex, NULL) != 0) {
55+
printf("Failed to init mutex.\n");
56+
return EXIT_FAILURE;
57+
}
58+
59+
for (int i = 0; i < NUM_THREADS; i++) {
60+
assert(start_args_init(&data[i].base));
61+
thread_ids[i] = __wasi_thread_spawn(&data[i]);
62+
assert(thread_ids[i] > 0 && "Thread creation failed");
63+
}
64+
65+
printf("Wait for threads to finish\n");
66+
for (int i = 0; i < NUM_THREADS; i++) {
67+
if (__builtin_wasm_memory_atomic_wait32(&data[i].th_done, 0, TIMEOUT)
68+
== 2) {
69+
assert(false && "Wait should not time out");
70+
}
71+
72+
start_args_deinit(&data[i].base);
73+
}
74+
75+
printf("Value of count after update: %d\n", g_count);
76+
assert(g_count == (NUM_THREADS * NUM_ITER)
77+
&& "Global count not updated correctly");
78+
79+
if (pthread_mutex_destroy(&mutex) != 0) {
80+
printf("Failed to init mutex.\n");
81+
return EXIT_FAILURE;
82+
}
83+
84+
return EXIT_SUCCESS;
85+
}

‎core/iwasm/libraries/wasi-threads/test/spawn_multiple_times.c‎

Lines changed: 75 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,75 @@
1+
/*
2+
* Copyright (C) 2023 Amazon.com Inc. or its affiliates. All rights reserved.
3+
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
4+
*/
5+
6+
#ifndef __wasi__
7+
#error This example only compiles to WASM/WASI target
8+
#endif
9+
10+
#include <stdlib.h>
11+
#include <stdio.h>
12+
#include <assert.h>
13+
#include <stdbool.h>
14+
15+
#include "wasi_thread_start.h"
16+
17+
enum CONSTANTS {
18+
NUM_ITER = 50,
19+
NUM_RETRY = 5,
20+
SECOND = 1000 * 1000 * 1000, /* 1 second */
21+
TIMEOUT = 5LL * SECOND
22+
};
23+
24+
typedef struct {
25+
start_args_t base;
26+
int th_done;
27+
} shared_t;
28+
29+
int g_count = 0;
30+
31+
void
32+
__wasi_thread_start_C(int thread_id, int *start_arg)
33+
{
34+
shared_t *data = (shared_t *)start_arg;
35+
36+
g_count++;
37+
38+
__atomic_store_n(&data->th_done, 1, __ATOMIC_SEQ_CST);
39+
__builtin_wasm_memory_atomic_notify(&data->th_done, 1);
40+
}
41+
42+
int
43+
main(int argc, char **argv)
44+
{
45+
shared_t data = { 0 };
46+
if (!start_args_init(&data.base)) {
47+
printf("Stack allocation for thread failed\n");
48+
return EXIT_FAILURE;
49+
}
50+
51+
for (int i = 0; i < NUM_ITER; i++) {
52+
data.th_done = 0;
53+
54+
printf("Creating thread\n");
55+
int thread_id = -1;
56+
for (int j = 0; j < NUM_RETRY && thread_id < 0; j++) {
57+
thread_id = __wasi_thread_spawn(&data);
58+
if (thread_id < 0)
59+
__builtin_wasm_memory_atomic_wait32(NULL, 0, SECOND);
60+
}
61+
assert(thread_id > 0 && "Thread creation should succeed");
62+
63+
printf("Waiting for thread to finish\n");
64+
if (__builtin_wasm_memory_atomic_wait32(&data.th_done, 0, TIMEOUT)
65+
== 2) {
66+
assert(false && "Wait should not time out");
67+
}
68+
printf("Thread has finished\n");
69+
}
70+
71+
assert(g_count == NUM_ITER && "Count has not been updated correctly");
72+
73+
start_args_deinit(&data.base);
74+
return EXIT_SUCCESS;
75+
}

0 commit comments

Comments
 (0)