@ai-ecoverse/slicc-kernel 1.66.1 → 1.67.0

package/dist/process-worker.js

@@ -101,6 +101,127 @@ var init_lockdown = __esm({
   }
 });
 
+// src/realm/sync-sab-wire.ts
+function loadU53(header, lo, hi) {
+  return (Atomics.load(header, lo) >>> 0) + Atomics.load(header, hi) * U32;
+}
+function publishMemory(sab, bytes) {
+  if (bytes > 0)
+    Atomics.store(new Int32Array(sab, 0, SAB_HEADER_I32), SAB_I_MEMORY, Math.ceil(bytes / 65536));
+}
+function decodeSabResult(status2, payload) {
+  switch (status2) {
+    case SAB_STATUS_BYTES:
+      return { ok: true, kind: "bytes", bytes: payload };
+    case SAB_STATUS_VOID:
+      return { ok: true, kind: "void" };
+    case SAB_STATUS_JSON: {
+      try {
+        return { ok: true, kind: "json", json: JSON.parse(decoder.decode(payload)) };
+      } catch {
+        return { ok: false, errno: "EIO", message: "sync-sab: malformed json payload" };
+      }
+    }
+    case SAB_STATUS_ERRNO: {
+      try {
+        const parsed = JSON.parse(decoder.decode(payload));
+        const errno2 = typeof parsed.errno === "string" && /^E[A-Z]+$|^EAI_[A-Z]+$/.test(parsed.errno) ? parsed.errno : "EIO";
+        return { ok: false, errno: errno2, message: String(parsed.message ?? errno2) };
+      } catch {
+        return { ok: false, errno: "EIO", message: "sync-sab: malformed errno payload" };
+      }
+    }
+    default:
+      return { ok: false, errno: "EIO", message: `sync-sab: unknown status ${status2}` };
+  }
+}
+function sabViews(sab) {
+  if (sab.byteLength < SAB_MIN_BYTES) {
+    throw new Error(`sync-sab: buffer too small (${sab.byteLength} < ${SAB_MIN_BYTES})`);
+  }
+  return {
+    header: new Int32Array(sab, 0, SAB_HEADER_I32),
+    window: new Uint8Array(sab, SAB_HEADER_BYTES)
+  };
+}
+var SAB_HEADER_I32, SAB_CLOCK_OFFSET, SAB_CLOCK_I64, SAB_HEADER_BYTES, SAB_I_STATE, SAB_I_SEQ, SAB_I_STATUS, SAB_I_TOTAL, SAB_I_CHUNK, SAB_I_OFFSET, SAB_I_REQ, SAB_I_PUB, SAB_I_SIGNALS, SAB_I_TIMERS, SAB_I_MEMORY, SAB_I_TOTAL_HI, SAB_I_OFFSET_HI, SAB_I_KILLED, SAB_I_ASYNC, SAB_I_STOP, U32, SAB_STATE_IDLE, SAB_STATE_PENDING, SAB_STATE_READY, SAB_STATUS_BYTES, SAB_STATUS_JSON, SAB_STATUS_VOID, SAB_STATUS_ERRNO, SAB_DEFAULT_WINDOW_BYTES, SAB_MIN_BYTES, SYNC_SAB_REQ_MSG, SYNC_SAB_NEXT_MSG, encoder, decoder;
+var init_sync_sab_wire = __esm({
+  "src/realm/sync-sab-wire.ts"() {
+    "use strict";
+    SAB_HEADER_I32 = 16;
+    SAB_CLOCK_OFFSET = SAB_HEADER_I32 * 4;
+    SAB_CLOCK_I64 = 3;
+    SAB_HEADER_BYTES = SAB_CLOCK_OFFSET + SAB_CLOCK_I64 * 8;
+    SAB_I_STATE = 0;
+    SAB_I_SEQ = 1;
+    SAB_I_STATUS = 2;
+    SAB_I_TOTAL = 3;
+    SAB_I_CHUNK = 4;
+    SAB_I_OFFSET = 5;
+    SAB_I_REQ = 6;
+    SAB_I_PUB = 7;
+    SAB_I_SIGNALS = 8;
+    SAB_I_TIMERS = 9;
+    SAB_I_MEMORY = 10;
+    SAB_I_TOTAL_HI = 11;
+    SAB_I_OFFSET_HI = 12;
+    SAB_I_KILLED = 13;
+    SAB_I_ASYNC = 14;
+    SAB_I_STOP = 15;
+    U32 = 2 ** 32;
+    SAB_STATE_IDLE = 0;
+    SAB_STATE_PENDING = 1;
+    SAB_STATE_READY = 2;
+    SAB_STATUS_BYTES = 1;
+    SAB_STATUS_JSON = 2;
+    SAB_STATUS_VOID = 3;
+    SAB_STATUS_ERRNO = 4;
+    SAB_DEFAULT_WINDOW_BYTES = 1024 * 1024;
+    SAB_MIN_BYTES = SAB_HEADER_BYTES + 4096;
+    SYNC_SAB_REQ_MSG = "sync-sab-req";
+    SYNC_SAB_NEXT_MSG = "sync-sab-next";
+    encoder = new TextEncoder();
+    decoder = new TextDecoder();
+  }
+});
+
+// src/kernel/cpu-clock.ts
+function epochMicros() {
+  return Math.floor((performance.timeOrigin + performance.now()) * 1e3);
+}
+function slots(sab) {
+  return new BigInt64Array(sab, LOCAL, SAB_CLOCK_I64);
+}
+function useLocalClock(sab) {
+  local = sab && sab.byteLength >= LOCAL + SAB_CLOCK_I64 * 8 ? slots(sab) : void 0;
+  if (!local) return;
+  const wait2 = (typed, index3, value2, timeout) => localWait(() => rawWait(typed, index3, value2, timeout));
+  Atomics.wait = wait2;
+}
+function localWait(wait2) {
+  const clock = local;
+  if (!clock) return wait2();
+  const start2 = BigInt(epochMicros());
+  const idle = Atomics.load(clock, IDLE);
+  Atomics.store(clock, IDLE, idle - start2);
+  try {
+    return wait2();
+  } finally {
+    const end = BigInt(epochMicros());
+    Atomics.store(clock, IDLE, idle + (end > start2 ? end - start2 : 0n));
+  }
+}
+var LOCAL, IDLE, local, rawWait;
+var init_cpu_clock = __esm({
+  "src/kernel/cpu-clock.ts"() {
+    "use strict";
+    init_sync_sab_wire();
+    LOCAL = SAB_CLOCK_OFFSET;
+    IDLE = 1;
+    rawWait = Atomics.wait.bind(Atomics);
+  }
+});
+
 // src/kernel/protocol.ts
 var WASM_PROCESS_INIT, WASM_PROCESS_EXIT, WASM_PROCESS_ERROR, WASM_THREAD_SPAWN, WASM_THREAD_INIT, WASM_THREAD_EXIT, WASM_MAX_THREADS, WASM_DEFAULT_THREADS;
 var init_protocol = __esm({
@@ -1625,93 +1746,11 @@ var init_emscripten_vfs_hook = __esm({
   }
 });
 
-// src/realm/sync-sab-wire.ts
-function loadU53(header, lo, hi) {
-  return (Atomics.load(header, lo) >>> 0) + Atomics.load(header, hi) * U32;
-}
-function publishMemory(sab, bytes) {
-  if (bytes > 0)
-    Atomics.store(new Int32Array(sab, 0, SAB_HEADER_I32), SAB_I_MEMORY, Math.ceil(bytes / 65536));
-}
-function decodeSabResult(status2, payload) {
-  switch (status2) {
-    case SAB_STATUS_BYTES:
-      return { ok: true, kind: "bytes", bytes: payload };
-    case SAB_STATUS_VOID:
-      return { ok: true, kind: "void" };
-    case SAB_STATUS_JSON: {
-      try {
-        return { ok: true, kind: "json", json: JSON.parse(decoder.decode(payload)) };
-      } catch {
-        return { ok: false, errno: "EIO", message: "sync-sab: malformed json payload" };
-      }
-    }
-    case SAB_STATUS_ERRNO: {
-      try {
-        const parsed = JSON.parse(decoder.decode(payload));
-        const errno2 = typeof parsed.errno === "string" && /^E[A-Z]+$|^EAI_[A-Z]+$/.test(parsed.errno) ? parsed.errno : "EIO";
-        return { ok: false, errno: errno2, message: String(parsed.message ?? errno2) };
-      } catch {
-        return { ok: false, errno: "EIO", message: "sync-sab: malformed errno payload" };
-      }
-    }
-    default:
-      return { ok: false, errno: "EIO", message: `sync-sab: unknown status ${status2}` };
-  }
-}
-function sabViews(sab) {
-  if (sab.byteLength < SAB_MIN_BYTES) {
-    throw new Error(`sync-sab: buffer too small (${sab.byteLength} < ${SAB_MIN_BYTES})`);
-  }
-  return {
-    header: new Int32Array(sab, 0, SAB_HEADER_I32),
-    window: new Uint8Array(sab, SAB_HEADER_BYTES)
-  };
-}
-var SAB_HEADER_I32, SAB_HEADER_BYTES, SAB_I_STATE, SAB_I_SEQ, SAB_I_STATUS, SAB_I_TOTAL, SAB_I_CHUNK, SAB_I_OFFSET, SAB_I_REQ, SAB_I_PUB, SAB_I_SIGNALS, SAB_I_TIMERS, SAB_I_MEMORY, SAB_I_TOTAL_HI, SAB_I_OFFSET_HI, SAB_I_KILLED, SAB_I_ASYNC, SAB_I_STOP, U32, SAB_STATE_IDLE, SAB_STATE_PENDING, SAB_STATE_READY, SAB_STATUS_BYTES, SAB_STATUS_JSON, SAB_STATUS_VOID, SAB_STATUS_ERRNO, SAB_DEFAULT_WINDOW_BYTES, SAB_MIN_BYTES, SYNC_SAB_REQ_MSG, SYNC_SAB_NEXT_MSG, encoder, decoder;
-var init_sync_sab_wire = __esm({
-  "src/realm/sync-sab-wire.ts"() {
-    "use strict";
-    SAB_HEADER_I32 = 16;
-    SAB_HEADER_BYTES = SAB_HEADER_I32 * 4;
-    SAB_I_STATE = 0;
-    SAB_I_SEQ = 1;
-    SAB_I_STATUS = 2;
-    SAB_I_TOTAL = 3;
-    SAB_I_CHUNK = 4;
-    SAB_I_OFFSET = 5;
-    SAB_I_REQ = 6;
-    SAB_I_PUB = 7;
-    SAB_I_SIGNALS = 8;
-    SAB_I_TIMERS = 9;
-    SAB_I_MEMORY = 10;
-    SAB_I_TOTAL_HI = 11;
-    SAB_I_OFFSET_HI = 12;
-    SAB_I_KILLED = 13;
-    SAB_I_ASYNC = 14;
-    SAB_I_STOP = 15;
-    U32 = 2 ** 32;
-    SAB_STATE_IDLE = 0;
-    SAB_STATE_PENDING = 1;
-    SAB_STATE_READY = 2;
-    SAB_STATUS_BYTES = 1;
-    SAB_STATUS_JSON = 2;
-    SAB_STATUS_VOID = 3;
-    SAB_STATUS_ERRNO = 4;
-    SAB_DEFAULT_WINDOW_BYTES = 1024 * 1024;
-    SAB_MIN_BYTES = SAB_HEADER_BYTES + 4096;
-    SYNC_SAB_REQ_MSG = "sync-sab-req";
-    SYNC_SAB_NEXT_MSG = "sync-sab-next";
-    encoder = new TextEncoder();
-    decoder = new TextDecoder();
-  }
-});
-
 // src/realm/sync-sab-bridge.ts
 function createSyncSabTransport(sab, port2, deps = {}) {
   const views = sabViews(sab);
   const { header, window } = views;
-  const wait2 = deps.wait ?? ((a, i, v, t) => Atomics.wait(a, i, v, t));
+  const wait2 = deps.wait ?? ((a, i, v, t) => rawWait(a, i, v, t));
   const now = deps.now ?? (() => performance.now());
   let seq = 0;
   function awaitReady(id, deadline, label) {
@@ -1915,6 +1954,7 @@ function createSyncFsSabBridge(transport, opts = {}) {
 var init_sync_sab_bridge = __esm({
   "src/realm/sync-sab-bridge.ts"() {
     "use strict";
+    init_cpu_clock();
     init_sync_fs_wire();
     init_sync_sab_wire();
   }
@@ -3153,13 +3193,13 @@ function describeInherited(Fs, sys, streams, livePath, actions = []) {
     if (from) table.set(target, { stream: from.stream, cloexec: false });
     else table.delete(target);
   }
-  const slots2 = /* @__PURE__ */ new Map();
+  const slots3 = /* @__PURE__ */ new Map();
   for (const [fd, { stream, cloexec }] of table) {
-    if (fd > 2 && !cloexec) slots2.set(fd, stream);
+    if (fd > 2 && !cloexec) slots3.set(fd, stream);
   }
   const promote = vfsPromoter(Fs, sys, streams, livePath);
   const out = [];
-  for (const [fd, stream] of slots2) {
+  for (const [fd, stream] of slots3) {
     promote(stream);
     const slot = inheritedSlot(fd, stream);
     if (slot) out.push(slot);
@@ -3358,12 +3398,12 @@ function anySelect(Fs, transport, read2, write2, timeoutMs) {
   const kernelRead = read2.filter((fd) => !own(fd));
   const kernelWrite = write2.filter((fd) => !own(fd));
   for (; ; ) {
-    const local = ownReady(Fs, read2.filter(own), write2.filter(own));
-    const pending = local.read.length > 0 || local.write.length > 0;
+    const local2 = ownReady(Fs, read2.filter(own), write2.filter(own));
+    const pending = local2.read.length > 0 || local2.write.length > 0;
     const slice = pending ? 0 : Math.min(SELECT_SLICE_MS, Math.max(0, deadline - Date.now()));
     const got = kernelSelect(Fs, transport, kernelRead, kernelWrite, slice);
     if (typeof got === "number") return got;
-    const ready = { read: [...local.read, ...got.read], write: [...local.write, ...got.write] };
+    const ready = { read: [...local2.read, ...got.read], write: [...local2.write, ...got.write] };
     if (ready.read.length > 0 || ready.write.length > 0 || Date.now() >= deadline) {
       return ready;
     }
@@ -3902,8 +3942,8 @@ function pidStat(info, boot) {
     0,
     0,
     0,
-    0,
-    0,
+    ticks(info.utime ?? 0),
+    ticks(info.stime ?? 0),
     0,
     0,
     20,
@@ -3996,19 +4036,23 @@ function systemFile(name2, listing, now, memory) {
   if (name2 === "meminfo") {
     return memoryInfo(
       memory,
-      listing.processes.reduce((sum, p) => sum + p.memory, 0)
+      listing.processes.reduce((sum2, p) => sum2 + p.memory, 0)
     );
   }
   const live = listing.processes.filter((p) => p.state !== "Z");
   if (name2 === "loadavg") {
     const last = Math.max(0, ...listing.processes.map((p) => p.pid));
-    return `0.00 0.00 0.00 1/${live.length} ${last}
+    const [one, five, fifteen] = (listing.load ?? [0, 0, 0]).map((n) => n.toFixed(2));
+    return `${one} ${five} ${fifteen} 1/${live.length} ${last}
 `;
   }
-  const idle = ticks(now - listing.boot);
+  const sum = (key) => listing.cpu?.[key] ?? listing.processes.reduce((n, p) => n + (p[key] ?? 0), 0);
+  const user = ticks(sum("utime"));
+  const system = ticks(sum("stime"));
+  const idle = listing.cpu ? ticks(listing.cpu.idle) : Math.max(0, ticks(now - listing.boot) - user - system);
   return [
-    `cpu  0 0 0 ${idle} 0 0 0 0 0 0`,
-    `cpu0 0 0 0 ${idle} 0 0 0 0 0 0`,
+    `cpu  ${user} 0 ${system} ${idle} 0 0 0 0 0 0`,
+    `cpu0 ${user} 0 ${system} ${idle} 0 0 0 0 0 0`,
     "intr 0",
     "ctxt 0",
     `btime ${Math.floor(listing.boot / 1e3)}`,
@@ -7307,8 +7351,8 @@ var init_wasix_process = __esm({
         ];
         return { stdio, inherit, cwd, opened };
       }
-      applyFdOp(op, slots2, cwd) {
-        const { map, nulls, opened } = slots2;
+      applyFdOp(op, slots3, cwd) {
+        const { map, nulls, opened } = slots3;
         const { fds } = this.host;
         const point = (fd, kfd) => {
           if (kfd === void 0) {
@@ -10909,7 +10953,7 @@ function childOps(kernel, io, defaults) {
     const mine = [];
     const theirs = [];
     try {
-      const stdio = await slots(kernel, o, mine, theirs);
+      const stdio = await slots2(kernel, o, mine, theirs);
       const pid = await kernel.json({
         op: "proc-spawn",
         file,
@@ -10938,7 +10982,7 @@ async function preflight(kernel, hows) {
     await kernel.json({ op: "fd-info", fd: how === "inherit" ? n : how });
   }
 }
-async function slots(kernel, o, mine, theirs) {
+async function slots2(kernel, o, mine, theirs) {
   const hows = STDIO2.map((name2) => o[name2] ?? "inherit");
   await preflight(kernel, hows);
   const stdio = [];
@@ -11488,7 +11532,7 @@ function port(n) {
 function netOps(kernel, io) {
   const name2 = async (fd, peer) => addressOf(await kernel.json({ op: "sock-name", fd, peer }));
   const connection = async (fd) => {
-    const [local, remote] = [await name2(fd, false), await name2(fd, true)];
+    const [local2, remote] = [await name2(fd, false), await name2(fd, true)];
     const stop = new AbortController();
     let closed;
     const close = () => {
@@ -11513,7 +11557,7 @@ function netOps(kernel, io) {
       close: async () => void await shut(SHUT_WR),
       abort: () => close()
     });
-    return { fd, local, remote, readable: readable2, writable: writable2, close };
+    return { fd, local: local2, remote, readable: readable2, writable: writable2, close };
   };
   const resolve = async (host, signal) => {
     if (IPV4.test(host)) return host;
@@ -12630,6 +12674,7 @@ var init_js_runtime = __esm({
 init_lockdown();
 
 // src/process/process-entry.ts
+init_cpu_clock();
 init_protocol();
 init_process_runtime();
 var loadWasi = () => Promise.resolve().then(() => (init_wasi_runtime(), wasi_runtime_exports));
@@ -12667,6 +12712,8 @@ function processEntry(port2, run = runWasmProcess, wasi = loadWasi, js = loadJs,
     const type = data?.type;
     if (type !== WASM_THREAD_INIT && type !== WASM_PROCESS_INIT) return;
     const refusal2 = sealOnce();
+    const init = data;
+    if (type === WASM_THREAD_INIT || init?.program?.abi !== "js") useLocalClock(init?.sab);
     if (type === WASM_THREAD_INIT) {
       if (refusal2) return failed5(refusal2.error);
       wasi().then((m) => m.runWasiThread(data, port2)).catch(failed5);