@ai-ecoverse/slicc-kernel 1.66.0 → 1.67.0

package/dist/node-process-worker.js

@@ -3115,8 +3115,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) {
@@ -3512,12 +3512,14 @@ function sabViews(sab) {
     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, decoder2;
+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, decoder2;
 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_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;
@@ -4496,7 +4498,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 = () => {
@@ -4521,7 +4523,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;
@@ -4682,11 +4684,48 @@ var init_js_run = __esm({
   }
 });
 
+// src/kernel/cpu-clock.ts
+function epochMicros() {
+  return Math.floor((performance.timeOrigin + performance.now()) * 1e3);
+}
+function slots2(sab) {
+  return new BigInt64Array(sab, LOCAL, SAB_CLOCK_I64);
+}
+function useLocalClock(sab) {
+  local = sab && sab.byteLength >= LOCAL + SAB_CLOCK_I64 * 8 ? slots2(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/realm/sync-sab-bridge.ts
 function createSyncSabTransport(sab, port3, 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) {
@@ -4890,6 +4929,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();
   }
@@ -8024,13 +8064,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);
@@ -8229,12 +8269,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;
     }
@@ -8754,8 +8794,8 @@ function pidStat(info, boot) {
     0,
     0,
     0,
-    0,
-    0,
+    ticks(info.utime ?? 0),
+    ticks(info.stime ?? 0),
     0,
     0,
     20,
@@ -8848,19 +8888,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)}`,
@@ -12681,6 +12725,7 @@ function nodeLockdown(scope2 = globalThis) {
 init_js_runtime();
 
 // src/process/process-entry.ts
+init_cpu_clock();
 init_protocol();
 init_process_runtime();
 var loadWasi = () => Promise.resolve().then(() => (init_wasi_runtime(), wasi_runtime_exports));
@@ -12718,6 +12763,8 @@ function processEntry(port3, 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, port3)).catch(failed5);