runtime/wasip1: add opt-in threaded GC for WAMR

.github/actions/setup-deps/action.yml

@@ -819,21 +819,32 @@ runs:
       shell: bash
       run: |
         set -euo pipefail
+        python3 "$GITHUB_ACTION_PATH/ubuntu_apt_test.py"
+        sudo python3 "$GITHUB_ACTION_PATH/ubuntu_apt.py" /etc/apt "$(dpkg --print-architecture)"
+        apt_get() {
+          local limit=10m
+          if [[ "$1" == "update" ]]; then
+            limit=5m
+          fi
+          # Per-download timeouts alone do not bound an entire mirror-list
+          # transaction. Fail with diagnostics before exhausting the job.
+          sudo timeout --kill-after=30s "$limit" apt-get "$@"
+        }
         # Install LLVM if requested
         if [[ "${{ inputs.install-llvm }}" == "true" ]]; then
-          echo "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-${{inputs.llvm-version}} main" | sudo tee /etc/apt/sources.list.d/llvm.list
+          echo "deb https://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-${{inputs.llvm-version}} main" | sudo tee /etc/apt/sources.list.d/llvm.list
           # Some Linux runners resolve IPv6 addresses without an IPv6 route.
           # Retry transient DNS errors, but keep HTTPS and bounded failures.
           wget -4 --retry-on-host-error --tries=3 --timeout=15 --waitretry=2 -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
-          sudo apt-get update
-          sudo apt-get install -y llvm-${{inputs.llvm-version}}-dev clang-${{inputs.llvm-version}} libclang-${{inputs.llvm-version}}-dev lld-${{inputs.llvm-version}} libunwind-${{inputs.llvm-version}}-dev libc++-${{inputs.llvm-version}}-dev
+          apt_get update
+          apt_get install -y llvm-${{inputs.llvm-version}}-dev clang-${{inputs.llvm-version}} libclang-${{inputs.llvm-version}}-dev lld-${{inputs.llvm-version}} libunwind-${{inputs.llvm-version}}-dev libc++-${{inputs.llvm-version}}-dev
           echo "PATH=/usr/lib/llvm-${{inputs.llvm-version}}/bin:$PATH" >> $GITHUB_ENV
         else
-          sudo apt-get update
+          apt_get update
         fi
 
         # Install common dependencies
-        sudo apt-get install -y cmake pkg-config libgc-dev libssl-dev zlib1g-dev libffi-dev libcjson-dev libuv1-dev
+        apt_get install -y cmake pkg-config libgc-dev libssl-dev zlib1g-dev libffi-dev libcjson-dev libuv1-dev
 
         # Install optional deps for demos.
         #
@@ -843,4 +854,4 @@ runs:
           libsqlite3-dev # for github.com/goplus/lib/c/sqlite
           python3.12-dev # for github.com/goplus/lib/py
         )
-        sudo apt-get install -y "${opt_deps[@]}"
+        apt_get install -y "${opt_deps[@]}"

.github/actions/setup-deps/ubuntu_apt.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+
+"""Configure the runner's Ubuntu mirror lists and bounded APT downloads."""
+
+import pathlib
+import sys
+
+
+def configure(apt_dir, architecture):
+    if architecture in ("amd64", "i386"):
+        archive = "https://archive.ubuntu.com/ubuntu/"
+        security = "https://security.ubuntu.com/ubuntu/"
+    else:
+        archive = security = "https://ports.ubuntu.com/ubuntu-ports/"
+
+    # The runner's mirror+file source selected a malformed https:/ URL and
+    # then stalled on another mirror for the entire 45-minute Wasm job.
+    # Preserve source suites, components and signing keys; replace only the
+    # two Ubuntu mirror lists when the runner already uses them.
+    for name, url in (("apt-mirrors.txt", archive),
+                      ("apt-mirrors-security.txt", security)):
+        path = apt_dir / name
+        if path.exists():
+            path.write_text(url + "\n")
+
+    (apt_dir / "apt.conf.d" / "80-llgo-downloads").write_text('''\
+Acquire::ForceIPv4 "true";
+Acquire::Retries "3";
+Acquire::http::Timeout "30";
+Acquire::https::Timeout "30";
+APT::Update::Error-Mode "any";
+''')
+
+
+if __name__ == "__main__":
+    configure(pathlib.Path(sys.argv[1]), sys.argv[2])

.github/actions/setup-deps/ubuntu_apt_test.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+
+import pathlib
+import tempfile
+import unittest
+
+from ubuntu_apt import configure
+
+
+class UbuntuAPTTest(unittest.TestCase):
+    def test_runner_mirror_lists(self):
+        for arch, archive, security in (
+            ("amd64", "https://archive.ubuntu.com/ubuntu/",
+             "https://security.ubuntu.com/ubuntu/"),
+            ("arm64", "https://ports.ubuntu.com/ubuntu-ports/",
+             "https://ports.ubuntu.com/ubuntu-ports/"),
+        ):
+            with self.subTest(arch=arch), tempfile.TemporaryDirectory() as tmp:
+                root = pathlib.Path(tmp)
+                (root / "apt.conf.d").mkdir()
+                for name in ("apt-mirrors.txt", "apt-mirrors-security.txt"):
+                    (root / name).write_text(
+                        "https:/us.archive.ubuntu.com/ubuntu\n"
+                        "https://mirrors.edge.kernel.org/ubuntu\n")
+                sources = root / "ubuntu.sources"
+                source_text = "URIs: mirror+file:/etc/apt/apt-mirrors.txt\nSigned-By: /usr/share/keyrings/ubuntu-archive-keyring.gpg\n"
+                sources.write_text(source_text)
+                third_party = root / "custom-mirrors.txt"
+                third_party.write_text("https://apt.llvm.org/noble/\n")
+                configure(root, arch)
+                configure(root, arch)
+                self.assertEqual((root / "apt-mirrors.txt").read_text(), archive + "\n")
+                self.assertEqual((root / "apt-mirrors-security.txt").read_text(), security + "\n")
+                self.assertEqual(sources.read_text(), source_text)
+                self.assertEqual(third_party.read_text(), "https://apt.llvm.org/noble/\n")
+
+    def test_direct_sources_need_no_mirror_lists(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = pathlib.Path(tmp)
+            (root / "apt.conf.d").mkdir()
+            configure(root, "amd64")
+            self.assertFalse((root / "apt-mirrors.txt").exists())
+            self.assertFalse((root / "apt-mirrors-security.txt").exists())
+            self.assertTrue((root / "apt.conf.d" / "80-llgo-downloads").is_file())
+
+
+if __name__ == "__main__":
+    unittest.main()

.github/workflows/llgo.yml

@@ -571,7 +571,7 @@ jobs:
 
           iwasm --stack-size=819200000 --heap-size=800000000 hello.wasm
 
-      - name: Test WASI pthread backend (WAMR)
+      - name: Test WASI pthread backend and threaded GC (WAMR)
         shell: bash
         run: python3 dev/test_wasm_wasi_threads.py
 

cmd/internal/run/run_test.go

@@ -1,6 +1,12 @@
 package run
 
-import "testing"
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/xgo-dev/llgo/internal/mockable"
+)
 
 func TestRunAndCmpTestBuildFlagsAreIndependent(t *testing.T) {
 	if runGoBuildFlags == cmpTestGoBuildFlags {
@@ -19,3 +25,18 @@ func TestRunAndCmpTestBuildFlagsAreIndependent(t *testing.T) {
 		t.Fatal("run or cmptest build flags are bound to the wrong command")
 	}
 }
+
+func TestRunPreservesNativeExitCode(t *testing.T) {
+	program := filepath.Join(t.TempDir(), "exit.go")
+	if err := os.WriteFile(program, []byte("package main\nimport \"os\"\nfunc main() { os.Exit(23) }\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	mockable.EnableMock()
+	defer mockable.DisableMock()
+	defer func() {
+		if recovered := recover(); recovered != "exit" || mockable.ExitCode() != 23 {
+			t.Errorf("llgo run exit = (%v, %d), want (exit, 23)", recovered, mockable.ExitCode())
+		}
+	}()
+	runCmd(Cmd, []string{program})
+}

dev/build_iwasm.sh

@@ -134,7 +134,9 @@ mkdir -p wasm-micro-runtime/product-mini/platforms/${PLATFORM}/build
 cd wasm-micro-runtime/product-mini/platforms/${PLATFORM}/build
 
 # The test helper executes Wasm bytecode only, so AOT is unnecessary; LLGo's
-# generated modules require reference-types support.
+# generated modules require reference-types support. WAMR 2.4.5's debug
+# interpreter leaves a termination signal after a caught Wasm exception;
+# a later branch then aborts LLVM's SjLj path for Go panic/recover.
 cmake "${CMAKE_GENERATOR_ARGS[@]}" \
     -D WAMR_BUILD_EXCE_HANDLING=1 \
     -D WAMR_BUILD_AOT=0 \
@@ -144,7 +146,7 @@ cmake "${CMAKE_GENERATOR_ARGS[@]}" \
     -D WAMR_BUILD_LIB_WASI_THREADS=1 \
     -D WAMR_BUILD_LIB_PTHREAD=1 \
     -D CMAKE_BUILD_TYPE=Debug \
-    -D WAMR_BUILD_DEBUG_INTERP=1 \
+    -D WAMR_BUILD_DEBUG_INTERP=0 \
     ..
 
 echo "Compiling iwasm..."

dev/test_wasm_single_worker.sh

@@ -306,10 +306,11 @@ run_llgo_test() {
 	# This command builds and runs two packages. CI spent 258 seconds on the
 	# first WASI package alone, then hit the old 300-second aggregate limit
 	# while building the second. Budget 300 seconds per package; each binary
-	# still has its own 30-second test deadline and bounded host runner.
+	# has a finite 90-second test deadline and bounded host runner. The EC32
+	# reflection tests exceeded 30 seconds as a complete package on CI.
 	echo "testing public llgo test command for ${target}"
 	run_with_timeout_limit 600s env TMPDIR="${temp_dir}" "${llgo_cmd}" test -target "${target}" -emulator \
-		-v -count=1 -timeout=30s "${test_fixture}" "${secondary_test_fixture}" 2>&1 | tee "${output}"
+		-v -count=1 -timeout=90s "${test_fixture}" "${secondary_test_fixture}" 2>&1 | tee "${output}"
 	grep -Fq "PASS" "${output}"
 	grep -Fq "TestScheduler" "${output}"
 	grep -Fq "wasm secondary package ok" "${output}"
@@ -357,7 +358,9 @@ run_llgo_go_profile_test() {
 	local pattern="${3:-}"
 	local fixture="${4:-${test_fixture}}"
 	local output="${work_dir}/${name}.out"
-	local test_args=(-v -count=1 -timeout=30s)
+	# The GOOS=js route runs the same reflection-heavy package as EC32.
+	# Keep its package deadline aligned with the public target route above.
+	local test_args=(-v -count=1 -timeout=90s)
 	if [[ -n "${pattern}" ]]; then
 		test_args+=(-run "${pattern}")
 	fi

dev/test_wasm_wasi_threads.py

@@ -14,39 +14,141 @@
 IWASM = os.environ.get("IWASM", "iwasm")
 
 
+def run_probe(env, directory, name, fixture, tags, marker, timeout,
+              max_threads=8, expected_exit=0):
+    module = pathlib.Path(directory) / f"{name}.wasm"
+    command = [LLGO, "build", "-target", "wasi"]
+    if tags:
+        command += ["-tags", tags]
+    command += ["-o", str(module), str(ROOT / "internal/build/testdata" / fixture)]
+    subprocess.run(
+        command,
+        check=True,
+        env=env,
+        timeout=180,
+    )
+    result = subprocess.run(
+        [IWASM, f"--max-threads={max_threads}", "--stack-size=1048576",
+         "--heap-size=0", "--dir=" + str(ROOT), "--dir=/tmp", str(module)],
+        capture_output=True,
+        text=True,
+        timeout=timeout,
+    )
+    print(result.stdout, end="")
+    print(result.stderr, end="")
+    allowed_exits = (expected_exit,) if isinstance(expected_exit, int) else expected_exit
+    if result.returncode not in allowed_exits or (
+        marker not in result.stdout.splitlines()
+        and marker not in result.stderr.splitlines()
+    ):
+        raise SystemExit(f"WAMR {name} probe failed with exit code {result.returncode}")
+
+
+def run_llgo(env, args, marker, timeout=180):
+    result = subprocess.run([LLGO, *args], capture_output=True, text=True,
+                            env=env, timeout=timeout)
+    print(result.stdout, end="")
+    print(result.stderr, end="")
+    if result.returncode != 0 or (
+        marker not in result.stdout.splitlines()
+        and marker not in result.stderr.splitlines()
+    ):
+        raise SystemExit(f"LLGo {' '.join(args)} failed with exit code {result.returncode}")
+
+
+def run_arena_boundaries(env, directory):
+    module = pathlib.Path(directory) / "gc-arena.wasm"
+    subprocess.run(
+        [LLGO, "build", "-target", "wasi", "-o", str(module),
+         str(ROOT / "internal/build/testdata/wasm-wasi-gc-arena")],
+        check=True, env=env, timeout=180,
+    )
+    # Each size needs a fresh heap: an earlier oversized arena could mask
+    # the bug by satisfying a later allocation from its unused capacity.
+    for size in ((32 << 20) - (128 << 10), (32 << 20) - 1,
+                 32 << 20, (32 << 20) + 1, 33 << 20):
+        result = subprocess.run(
+            [IWASM, "--max-threads=8", "--stack-size=1048576", "--heap-size=0",
+             str(module), str(size)], capture_output=True, text=True, timeout=180,
+        )
+        print(f"WAMR arena boundary: {size} bytes")
+        print(result.stdout, end="")
+        print(result.stderr, end="")
+        lines = result.stdout.splitlines() + result.stderr.splitlines()
+        if result.returncode != 0 or "wasi gc arena boundary ok" not in lines:
+            raise SystemExit(f"WAMR arena boundary {size} failed: {result.returncode}")
+
+
 def main():
-    if shutil.which(IWASM) is None:
+    iwasm = shutil.which(IWASM)
+    if iwasm is None:
         raise SystemExit(f"WAMR runner not found: {IWASM}")
 
     env = os.environ.copy()
     env["LLGO_ROOT"] = str(ROOT)
     env["LLGO_WASI_THREADS"] = "1"
+    env["PATH"] = str(pathlib.Path(iwasm).resolve().parent) + os.pathsep + env["PATH"]
     with tempfile.TemporaryDirectory(prefix="llgo-wasi-threads-") as directory:
-        module = pathlib.Path(directory) / "threads.wasm"
+        run_probe(env, directory, "startup", "wasm-wasi-thread-startup", "nogc",
+                  "wasi thread startup ok", 30, max_threads=32)
+        # WAMR can translate the terminal Wasm exception to process status 1
+        # instead of preserving the guest's status 2. Both are nonzero exits.
+        deadlock_exits = (1, 2)
+        run_probe(env, directory, "main-goexit", "wasm-wasi-main-goexit", "nogc",
+                  "fatal error: no goroutines (main called runtime.Goexit) - deadlock!",
+                  30, expected_exit=deadlock_exits)
+        run_probe(env, directory, "main-goexit-gc", "wasm-wasi-main-goexit", "",
+                  "fatal error: no goroutines (main called runtime.Goexit) - deadlock!",
+                  30, expected_exit=deadlock_exits)
+        run_probe(env, directory, "main-goexit-collect",
+                  "wasm-wasi-main-goexit-gc", "", "wasi goexit gc collected",
+                  30, expected_exit=deadlock_exits)
+        run_probe(env, directory, "main-goexit-timer", "wasm-wasi-main-goexit-timer",
+                  "nogc", "fatal error: no goroutines (main called runtime.Goexit) - deadlock!",
+                  30, expected_exit=deadlock_exits)
+        run_probe(env, directory, "main-goexit-timer-gc", "wasm-wasi-main-goexit-timer",
+                  "", "fatal error: no goroutines (main called runtime.Goexit) - deadlock!",
+                  30, expected_exit=deadlock_exits)
+        run_probe(env, directory, "threads", "wasm-wasi-threads", "nogc",
+                  "wasi threads ok", 30)
+        run_probe(env, directory, "threaded-gc", "wasm-wasi-threaded-gc",
+                  "", "wasi threaded gc ok", 180)
+        run_arena_boundaries(env, directory)
+        run_llgo(env, ["run", "-target", "wasi", "-emulator",
+                       str(ROOT / "internal/build/testdata/wasm-wasi-threads")],
+                 "wasi threads ok")
+        run_llgo(env, ["run", "-target", "wasi", "-emulator",
+                       str(ROOT / "internal/build/testdata/wasm-wasi-threaded-fs")],
+                 "wasi threaded filesystem ok")
+        run_llgo(env, ["test", "-target", "wasi", "-emulator",
+                       str(ROOT / "test/std/errors")], "PASS")
+        run_llgo(env, ["test", "-target", "wasi", "-emulator", "-run",
+                       "^TestPoolAfterGC$", str(ROOT / "test/std/sync")], "PASS",
+                 timeout=300)
+        run_llgo(env, ["test", "-target", "wasi", "-emulator",
+                       str(ROOT / "test/std/go/importer")], "PASS")
+        run_llgo(env, ["test", "-target", "wasi", "-emulator", "-run",
+                       "^(TestTBasicMethods|FuzzExample)$",
+                       str(ROOT / "test/std/testing")], "PASS")
+        run_llgo(env, ["test", "-target", "wasi", "-emulator",
+                       str(ROOT / "test/std/weak")], "PASS")
+        run_llgo(env, ["test", "-target", "wasi", "-emulator",
+                       "-run", "^TestConcurrentSelectProposeReplyStress$",
+                       str(ROOT / "test")], "PASS")
         subprocess.run(
-            [LLGO, "build", "-target", "wasi", "-tags", "nogc", "-o", str(module),
-             str(ROOT / "internal/build/testdata/wasm-wasi-threads")],
-            check=True,
-            env=env,
-            timeout=180,
+            ["go", "run", "./dev/wasmstdlib", "-profile", "W32-WASI",
+             "-llgo", LLGO, "-report", str(pathlib.Path(directory) / "w32-wamr.json")],
+            check=True, cwd=ROOT, env=env, timeout=600,
         )
-        result = subprocess.run(
-            # 52 probe workers, main, and the timer service can overlap while
-            # WAMR retires their host slots. Go's live-G count is not a join.
-            [IWASM, "--max-threads=64", "--stack-size=1048576",
-             "--heap-size=67108864", str(module)],
-            capture_output=True,
-            text=True,
-            timeout=30,
+        goroot = subprocess.check_output(["go", "env", "GOROOT"], env=env,
+                                         text=True).strip()
+        subprocess.run(
+            ["go", "test", "./test/goroot", "-run", "^TestGoRootRunCases$",
+             "-count=1", "-args", "-goroot", goroot, "-llgo", LLGO,
+             "-wasm-profile", "W32-WASI", "-directive-mode", "ci",
+             "-case", r"^helloworld\.go$", "-min-swap-free-mib=0"],
+            check=True, cwd=ROOT, env=env, timeout=180,
         )
-        print(result.stdout, end="")
-        print(result.stderr, end="")
-        marker = "wasi threads ok"
-        if result.returncode != 0 or (
-            marker not in result.stdout.splitlines()
-            and marker not in result.stderr.splitlines()
-        ):
-            raise SystemExit(f"WAMR WASI pthread probe failed with exit code {result.returncode}")
 
 
 if __name__ == "__main__":