@ai-ecoverse/slicc-kernel 1.100.4 → 1.101.0

package/dist/process-worker.js

@@ -2475,7 +2475,7 @@ var KERNEL_VERSION, OS_RELEASE;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    KERNEL_VERSION = true ? "1.100.4" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.101.0" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });
@@ -8358,6 +8358,7 @@ var init_wasi_host = __esm({
       signals;
       sigmask;
       linkedTls;
+      threadEntry;
       linkedModules;
       interrupted;
       quietly = (fn) => fn();
@@ -9509,6 +9510,7 @@ var init_wasix_process = __esm({
           ...this.host.linkedTls ? { tls: this.host.linkedTls() } : {},
           ...this.host.linkedModules ? { modules: this.host.linkedModules() } : {}
         };
+        if (this.host.threadEntry) wasi.entry = this.host.threadEntry;
         return this.call({
           op: "proc-fork",
           state: { memory, currData: 0, forkSp, callStackNames: [], ppid: this.host.o.pid, wasi },
@@ -10485,6 +10487,11 @@ var init_wasix_fork = __esm({
       useStack(pointer, low) {
         this.linked = { pointer, low };
       }
+      threadStack = false;
+      useThreadStack(pointer, low) {
+        this.useStack(pointer, low);
+        this.threadStack = true;
+      }
       bind(exports) {
         this.exports = exports;
         this.stackUpper = this.stackPointer();
@@ -10567,9 +10574,8 @@ var init_wasix_fork = __esm({
         return out;
       }
       dataPointer() {
-        if (this.linked && !(this.exports[STACK_POINTER] instanceof WebAssembly.Global)) {
-          return this.linked.low + 15 & ~15;
-        }
+        const own = this.exports[STACK_POINTER] instanceof WebAssembly.Global;
+        if (this.linked && (this.threadStack || !own)) return this.linked.low + 15 & ~15;
         const g = this.exports.__data_end;
         const dataEnd = g instanceof WebAssembly.Global ? g.value : 0;
         return dataEnd < this.stackUpper ? dataEnd + 15 & ~15 : 16;
@@ -12083,6 +12089,7 @@ __export(wasi_runtime_exports, {
   runWasiThread: () => runWasiThread,
   sigmaskOf: () => sigmaskOf,
   takeThreadDefault: () => takeThreadDefault,
+  threadStackLow: () => threadStackLow,
   trapMessage: () => trapMessage,
   unsupportedImport: () => unsupportedImport,
   wireSignals: () => wireSignals
@@ -12262,6 +12269,34 @@ function report(stats, sys) {
   } catch {
   }
 }
+function isWasix(module) {
+  return WebAssembly.Module.imports(module).some((i) => i.module === WASIX);
+}
+function threadStackLow(memory, start2) {
+  if (start2 < 0 || start2 + START_ARGS_SLACK > memory.byteLength) return void 0;
+  const stack = memory.getUint32(start2 + START_STACK, true);
+  const size = memory.getUint32(start2 + START_STACK_SIZE, true);
+  if (size < MIN_THREAD_STACK || size > memory.byteLength || size > stack) return void 0;
+  if (stack % 16 !== 0 || stack > start2 + START_ARGS_SLACK || stack + START_ARGS_SLACK < start2) {
+    return void 0;
+  }
+  return stack - size;
+}
+function ownStack(driver, instance, linked, low) {
+  const own = instance.exports.__stack_pointer;
+  const pointer = own instanceof WebAssembly.Global ? own : linked;
+  if (!pointer) return false;
+  driver.useThreadStack(pointer, low);
+  return true;
+}
+function untilDone(run, driver) {
+  do
+    run();
+  while (driver.resume());
+}
+function threadStart(instance) {
+  return instance.exports.wasi_thread_start;
+}
 function spawnsThreads(module) {
   return WebAssembly.Module.imports(module).some(
     (i) => i.module === "wasi" && i.name === "thread-spawn" || i.module === WASIX && i.name === "thread_spawn_v2"
@@ -12345,7 +12380,7 @@ async function instantiate(host, module, memory, threads, {
   }
   if (sync) bindLinker(host, sync, instance, { thread, forked, path });
   if (sync && !thread) driver.useStack(sync.linker.stackPointer, sync.linker.stackLow);
-  return { instance, driver };
+  return { instance, driver, linkedStack: sync?.linker.stackPointer };
 }
 function bindLinker(host, sync, instance, at) {
   sync.linker.bindMain(instance, !at.thread);
@@ -12463,7 +12498,7 @@ async function runWasiProcess(init, port2) {
     };
   }
   const program = await programImports(init.program, host, transport, MAIN_TID);
-  const { instance, driver } = await instantiate(host, module, memory, threads, {
+  const { instance, driver, linkedStack } = await instantiate(host, module, memory, threads, {
     ...fork ? { forked: fork } : {},
     stats,
     signals,
@@ -12483,11 +12518,15 @@ async function runWasiProcess(init, port2) {
   host.muted = (fd, data) => signals.muted(fd, data);
   const exports = instance.exports;
   driver.bind(instance.exports);
+  const entry = fork?.entry;
+  if (entry) {
+    ownStack(driver, instance, linkedStack, entry.low);
+    host.threadEntry = entry;
+  }
+  const run = entry ? () => threadStart(instance)(entry.tid, entry.arg) : () => exports._start();
   try {
     if (fork) driver.startChild(fork);
-    do
-      exports._start();
-    while (driver.resume());
+    untilDone(run, driver);
     return 0;
   } catch (e) {
     if (e instanceof WasiExit) return e.code;
@@ -12554,7 +12593,9 @@ async function runWasiThread(init, port2) {
   });
   host.sigmask = sigmaskOf(init.program.module, init.sab, gate, threads, init.signals);
   const program = await programImports(init.program, host, transport, thread.tid);
-  const { instance } = await instantiate(host, init.program.module, thread.memory, threads, {
+  const { module } = init.program;
+  const { memory } = thread;
+  const { instance, driver, linkedStack } = await instantiate(host, module, memory, threads, {
     thread: true,
     foreign: init.program.foreign,
     path: init.program.path,
@@ -12564,9 +12605,14 @@ async function runWasiThread(init, port2) {
   signals.register(SIGNAL_CALLBACK);
   wireSignals(host, gate);
   host.onRaise = (sig) => signals.raised(sig);
-  const start2 = instance.exports.wasi_thread_start;
+  const low = isWasix(module) ? threadStackLow(host.mem.view(), thread.arg) : void 0;
+  if (low !== void 0 && ownStack(driver, instance, linkedStack, low)) {
+    driver.bind(instance.exports);
+    host.threadEntry = { tid: thread.tid, arg: thread.arg, low };
+  }
+  const start2 = threadStart(instance);
   try {
-    start2(thread.tid, thread.arg);
+    untilDone(() => start2(thread.tid, thread.arg), driver);
     threads.exited();
   } catch (e) {
     if (e instanceof ThreadExit) {
@@ -12588,7 +12634,7 @@ async function runWasiThread(init, port2) {
     throw e;
   }
 }
-var TRAPPED, PREVIEW1, WASIX, SLICC, SIGNAL_CALLBACK, takeDefault, takeThreadDefault, SLICC_FS, SLICC_TTY, RESERVED2, UNDELIVERED, DELIVERED, importsSlicc, importsSigactionHook, noErrno, FALLBACK_MAXIMUM_PAGES, LinkSync, DL_GEN, BACKTRACE_FRAMES;
+var TRAPPED, PREVIEW1, WASIX, SLICC, SIGNAL_CALLBACK, takeDefault, takeThreadDefault, SLICC_FS, SLICC_TTY, RESERVED2, UNDELIVERED, DELIVERED, importsSlicc, importsSigactionHook, noErrno, FALLBACK_MAXIMUM_PAGES, START_STACK, START_STACK_SIZE, MIN_THREAD_STACK, START_ARGS_SLACK, LinkSync, DL_GEN, BACKTRACE_FRAMES;
 var init_wasi_runtime = __esm({
   "src/process/wasi/wasi-runtime.ts"() {
     "use strict";
@@ -12648,6 +12694,10 @@ var init_wasi_runtime = __esm({
     importsSigactionHook = (module) => importsSlicc(module, "sigaction_set");
     noErrno = (key) => `imports ${key}: its result cannot carry ENOSYS, and this host does not provide it`;
     FALLBACK_MAXIMUM_PAGES = 32768;
+    START_STACK = 0;
+    START_STACK_SIZE = 56;
+    MIN_THREAD_STACK = 4096;
+    START_ARGS_SLACK = 64;
     LinkSync = class {
       count = 0;
       gen = 0;