WASI: Implement experimental threading support

[Luukdegram]

This PR implements threading support for WASI. Note that WASI-threads is still an experimental feature and not all runtimes support it yet. The main goal of this PR is to not only add support for threads but also to gather feedback to improve the feature upstream.

Currently, the WASI-Threads proposal defines a single API entry which is wasi.thread-spawn, allowing us to pass a pointer to a context for later usage. This will ask the host to create an OS thread. Upon thread creation, an exported function wasi_thread_start will be called by the host environment. Providing us with a thread ID, and the original pointer we passed to thread-spawn. Although the host is responsible for creating and initializing the OS thread, it is up to the WebAssembly module to set up and initialize the memory for the thread. For this, we create enough memory to store:

• A guard page (to help prevent other threads from overwriting the memory of another thread)
  • This is done as best effort as there's no notion of read-only memory, yet.
• A new stack for the thread. (Set to user-specified size, or a single page, whichever is larger).
• A TLS segment
• Remaining memory required to store our Instance which holds metadata required to bootstrap the thread.

Upon thread creation, we then initialize the TLS segment and set the __tls_base pointer to this new TLS segment so loads and stores to TLS work correctly. We also set the stack pointer to the new stack that we created upon the call to spawn.

For WASI we ask the user to provide an allocator to ensure allocators are aware of any memory allocated by spawning a thread. Without this, it would be easy for the user to overwrite the memory we allocate during spawn as we can only grow pages sequentially and Wasm provides no way to tell what page is reserved and not. This also allows us to free the memory during join so the user's allocator can re-use memory that was previously allocated as there's currently no way in WebAssembly to free memory.
Unfortunately, this meant having to use a 'hack' during detach to free the memory (resetting the stack pointer upon thread exit to ensure we can free the memory using the allocator without using the stack that is being freed). The other option is to leak memory when a user uses detach. In the future, we can use memory.discard to handle freeing this memory and maybe get rid of the allocator from the API.

The next steps outside this PR are:

• Enable std tests, which requires us to:
  • Update CI Wasmtime to atleast v7.0.0
  • Update build.zig/test-runner to pass correct flags to Wasmtime to enable/run threading support.
• Add support for threads in WASI-LibC

For those wanting to play around with this, here's a test program with CLI invocation to both Zig and Wasmtime:

const std = @import("std");
pub fn main() !void {
    var threads: [3]std.Thread = undefined;
    var timer = try std.time.Timer.start();
    for (&threads, 0..3) |*thread, id| {
        thread.* = try std.Thread.spawn(.{ .allocator = std.heap.page_allocator }, myFunc, .{threads.len - id});
    }

    for (threads, 0..3) |thread, index| {
        thread.join();
    }
    std.debug.print("Total runtime: '{d}' ms\n", .{timer.read() / std.time.ns_per_ms});
}

fn myFunc(id: usize) void {
    std.debug.print("Sleeping {d} seconds on thread '{d}'\n", .{ id, std.Thread.getCurrentId() });
    std.time.sleep(id * std.time.ns_per_s);
    std.debug.print("Finished '{d}'\n", .{std.Thread.getCurrentId()});
}

Build thread.zig and run on Wasmtime:

zig build-exe thread.zig -femit-bin=thread.wasm -target wasm32-wasi --shared-memory -mcpu=mvp+atomics+bulk_memory --import-memory --export=wasi_thread_start --export-memory

wasmtime thread.wasm --wasm-features threads --wasi-modules experimental-wasi-threads

Output:

Sleeping 3 seconds on thread '1246793758'
Sleeping 2 seconds on thread '694100545'
Sleeping 1 seconds on thread '290362801'
Finished '290362801'
Finished '694100545'
Finished '1246793758'
Total runtime: '3010' ms

[andrewrk]

Nice work!

[albertxavier100]

Hello @andrewrk @Luukdegram ! Thanks for the great work on wasi thread support!!!

I'm new to zig, and try to build to target wasm32-wasi.

I use zig 0.13.0, and I try to enable multithread, but I got error: unknown argument: '-fno_single-threaded'.
and error: sub-compilation of libcxx failed.

I try to asio, and here's my build.zig:

const std = @import("std");

pub fn build(b: *std.Build) void {
    const target = b.resolveTargetQuery(
        .{
            .cpu_arch = std.Target.Cpu.Arch.wasm32,
            .os_tag = std.Target.Os.Tag.wasi,
        },
    );
    const optimize = b.standardOptimizeOption(.{});
    const exe = b.addExecutable(.{
        .name = "helloworld",
        .root_source_file = b.path("src/main.zig"),
        .target = target,
        .optimize = optimize,
    });
    exe.linkLibC();
    exe.linkLibCpp();
    exe.addCSourceFiles(.{
        .files = &.{"src/main.cpp"},
        .flags = &.{
            "-std=c++20",
            "-fno-sanitize=undefined",
            "-DASIO_STANDALONE=1",
            "-DASIO_HAS_CO_AWAIT=1",
            "-fno_single-threaded",
        },
    });
    exe.addIncludePath(b.path("deps/asio/asio/include/"));
    exe.addIncludePath(b.path("src/"));
    b.installArtifact(exe);
    
    .....
}

[jedisct1]

@albertxavier100 WASI threading doesn't work with the libc, only with native Zig code.

[vytskalt]

albertxavier100 WASI threading doesn't work with the libc, only with native Zig code.

Why is this the case? It looks wasm-libc has support for it: https://github.com/WebAssembly/wasi-libc?tab=readme-ov-file#building-in-pthread-support