@ai-ecoverse/slicc-kernel 1.66.1 → 1.67.0

package/dist/kernel-worker.js

@@ -7108,11 +7108,11 @@ var ChildTable = class {
     return [...this.children.keys()];
   }
   captured(pid, slot2) {
-    const slots = this.leftovers.get(pid);
-    const chunks = slots?.get(slot2);
-    if (!slots || !chunks) return new Uint8Array(0);
-    slots.delete(slot2);
-    if (slots.size === 0) this.leftovers.delete(pid);
+    const slots2 = this.leftovers.get(pid);
+    const chunks = slots2?.get(slot2);
+    if (!slots2 || !chunks) return new Uint8Array(0);
+    slots2.delete(slot2);
+    if (slots2.size === 0) this.leftovers.delete(pid);
     return concat3(chunks);
   }
 };
@@ -8584,7 +8584,9 @@ async function dispatchOne(entry, req) {
 
 // src/realm/sync-sab-wire.ts
 var SAB_HEADER_I32 = 16;
-var SAB_HEADER_BYTES = SAB_HEADER_I32 * 4;
+var SAB_CLOCK_OFFSET = SAB_HEADER_I32 * 4;
+var SAB_CLOCK_I64 = 3;
+var SAB_HEADER_BYTES = SAB_CLOCK_OFFSET + SAB_CLOCK_I64 * 8;
 var SAB_I_STATE = 0;
 var SAB_I_SEQ = 1;
 var SAB_I_STATUS = 2;
@@ -8734,6 +8736,146 @@ function attachSyncSabResponder(port, sab, token, opts) {
   };
 }
 
+// src/kernel/cpu-clock.ts
+var IDLE_OPS = /* @__PURE__ */ new Set([
+  "fd-select",
+  "proc-wait",
+  "proc-exec",
+  "sig-pause",
+  "sock-accept",
+  "sock-connect"
+]);
+var SYS_CAP_US = 2e4;
+var LOCAL = SAB_CLOCK_OFFSET;
+var IDLE = 1;
+function epochMicros() {
+  return Math.floor((performance.timeOrigin + performance.now()) * 1e3);
+}
+function slots(sab) {
+  return new BigInt64Array(sab, LOCAL, SAB_CLOCK_I64);
+}
+var rawWait = Atomics.wait.bind(Atomics);
+function localIdle(sab, now) {
+  const state = Number(Atomics.load(slots(sab), IDLE));
+  if (state >= 0) return { idle: state, waiting: false };
+  return { idle: Math.max(0, now + state), waiting: true };
+}
+var CpuClock = class {
+  start;
+  sys = 0;
+  idle = 0;
+  since = 0;
+  kind = "sys";
+  stopped = false;
+  last = { utime: 0, stime: 0 };
+  sab;
+  now;
+  constructor(sab, now = epochMicros) {
+    this.sab = sab;
+    this.now = now;
+    this.start = now();
+  }
+  enter(op) {
+    this.since = this.now();
+    this.kind = this.stopped || IDLE_OPS.has(op) ? "idle" : "sys";
+  }
+  leave() {
+    if (this.since === 0) return;
+    this.add((this.frozen ?? this.now()) - this.since);
+    this.since = 0;
+  }
+  stop(stopped) {
+    if (stopped === this.stopped) return;
+    this.stopped = stopped;
+    if (this.since === 0 || !stopped || this.frozen !== void 0) return;
+    const now = this.now();
+    this.add(now - this.since);
+    this.since = now;
+    this.kind = "idle";
+  }
+  frozen;
+  freeze() {
+    this.frozen ??= this.now();
+  }
+  running() {
+    if (this.frozen !== void 0) return false;
+    const now = this.now();
+    const busy = this.since === 0 || this.kind === "sys" && now - this.since < SYS_CAP_US;
+    return busy && !localIdle(this.sab, now).waiting;
+  }
+  times() {
+    const now = this.frozen ?? this.now();
+    const open = this.since === 0 ? 0 : Math.max(0, now - this.since);
+    const busy = this.kind === "sys" ? Math.min(open, SYS_CAP_US) : 0;
+    const sys = this.sys + busy;
+    const idle = this.idle + (open - busy) + localIdle(this.sab, now).idle;
+    const user = Math.max(0, now - this.start - sys - idle);
+    this.last = {
+      utime: Math.max(this.last.utime, Math.floor(user / 1e3)),
+      stime: Math.max(this.last.stime, Math.floor(sys / 1e3))
+    };
+    return this.last;
+  }
+  add(micros) {
+    const spent = Math.max(0, micros);
+    const busy = this.kind === "sys" ? Math.min(spent, SYS_CAP_US) : 0;
+    this.sys += busy;
+    this.idle += spent - busy;
+  }
+};
+var ProcessClocks = class {
+  main;
+  threads = /* @__PURE__ */ new Map();
+  ended = { utime: 0, stime: 0 };
+  enabled;
+  constructor(sab, enabled = true, states) {
+    this.main = new CpuClock(sab);
+    this.enabled = enabled;
+    states?.onState((state) => this.stop(state === "stopped"));
+  }
+  thread(tid, sab) {
+    const clock = new CpuClock(sab);
+    this.threads.set(tid, clock);
+    return clock;
+  }
+  threadEnded(tid) {
+    const spent = this.threads.get(tid)?.times();
+    this.threads.delete(tid);
+    if (!spent) return;
+    this.ended.utime += spent.utime;
+    this.ended.stime += spent.stime;
+  }
+  stop(stopped) {
+    for (const c of this.all()) c.stop(stopped);
+  }
+  freeze() {
+    for (const c of this.all()) c.freeze();
+  }
+  times() {
+    if (!this.enabled) return void 0;
+    const sum = { ...this.ended };
+    for (const c of this.all()) {
+      const t = c.times();
+      sum.utime += t.utime;
+      sum.stime += t.stime;
+    }
+    return sum;
+  }
+  running() {
+    return this.enabled ? this.all().filter((c) => c.running()).length : 0;
+  }
+  timed(clock, dispatch2) {
+    const c = clock ?? this.main;
+    return (req) => {
+      c.enter(req.op);
+      return dispatch2(req).finally(() => c.leave());
+    };
+  }
+  all() {
+    return [this.main, ...this.threads.values()];
+  }
+};
+
 // src/fs/pages.ts
 var PAGE = 64 * 1024;
 var READAHEAD = 1024 * 1024;
@@ -9018,8 +9160,8 @@ function pidStat(info, boot) {
     0,
     0,
     0,
-    0,
-    0,
+    ticks(info.utime ?? 0),
+    ticks(info.stime ?? 0),
     0,
     0,
     20,
@@ -9113,19 +9255,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)}`,
@@ -12264,6 +12410,9 @@ function killThread(thread, caught, sig) {
   blocked.abort();
   return true;
 }
+function threadSignalsOf(sab) {
+  return { header: new Int32Array(sab, 0, SAB_HEADER_I32), interrupt: new AbortController() };
+}
 function threadCancel(thread) {
   return Atomics.load(thread.header, SAB_I_SIGNALS) !== 0 ? AbortSignal.abort() : thread.interrupt.signal;
 }
@@ -12389,6 +12538,22 @@ function processOptions(opts, header3, hooks, created3) {
     ...opts.program.abi === "wasi" || opts.program.abi === "js" ? { pendingBits: () => Atomics.load(header3, SAB_I_SIGNALS) } : {}
   };
 }
+function threadInit(opts, program, sab, cred, thread) {
+  return {
+    type: WASM_THREAD_INIT,
+    pid: opts.shownPid ?? opts.pid,
+    program,
+    argv0: opts.argv0,
+    args: opts.args,
+    env: opts.env,
+    cwd: opts.cwd,
+    sab,
+    cred: copyCred(cred),
+    owners: opts.owners === true,
+    ...opts.ppid !== void 0 ? { ppid: opts.ppid } : {},
+    thread
+  };
+}
 function spawnWasmProcess(opts) {
   const sab = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DEFAULT_WINDOW_BYTES);
   const header3 = new Int32Array(sab, 0, SAB_HEADER_I32);
@@ -12421,7 +12586,10 @@ function spawnWasmProcess(opts) {
   const worker = opts.createWorker();
   const dying = new Dying();
   const dispatch2 = (req) => dying.serving(() => isWasmSyscall(req) ? process.syscall(req) : dispatchSyncFs(req));
-  const responder = attachSyncSabResponder(worker, sab, token, { dispatch: dispatch2 });
+  const clocks = new ProcessClocks(sab, opts.program.abi !== "js", process);
+  const responder = attachSyncSabResponder(worker, sab, token, {
+    dispatch: clocks.timed(void 0, dispatch2)
+  });
   const lane = opts.program.abi === "js" ? openLane(token, dispatch2) : void 0;
   const { promise: exited, resolve: settle3 } = Promise.withResolvers();
   let done4 = false;
@@ -12429,6 +12597,7 @@ function spawnWasmProcess(opts) {
   const finish = (code, sig) => {
     if (done4) return;
     done4 = true;
+    clocks.freeze();
     dying.clear();
     endedBy = sig ?? process.execTermsig;
     worker.removeEventListener("message", onMessage);
@@ -12469,6 +12638,7 @@ function spawnWasmProcess(opts) {
   const endThread = (tid) => {
     const end = threads.get(tid);
     threads.delete(tid);
+    clocks.threadEnded(tid);
     process.threadEnded(tid);
     end?.();
   };
@@ -12482,15 +12652,14 @@ function spawnWasmProcess(opts) {
     }
     const tsab = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DEFAULT_WINDOW_BYTES);
     const tw = opts.createWorker();
-    const tsignals = {
-      header: new Int32Array(tsab, 0, SAB_HEADER_I32),
-      interrupt: new AbortController()
-    };
+    const tsignals = threadSignalsOf(tsab);
     threadSignals.set(thread.tid, tsignals);
     const tdispatch = (req) => dying.serving(
       () => isWasmSyscall(req) ? process.syscall(req, threadCancel(tsignals)) : dispatchSyncFs(req)
     );
-    const tresponder = attachSyncSabResponder(tw, tsab, token, { dispatch: tdispatch });
+    const tresponder = attachSyncSabResponder(tw, tsab, token, {
+      dispatch: clocks.timed(clocks.thread(thread.tid, tsab), tdispatch)
+    });
     const onThreadMessage = (event) => {
       const data = event.data;
       if (data?.type === WASM_THREAD_EXIT) endThread(thread.tid);
@@ -12505,21 +12674,7 @@ function spawnWasmProcess(opts) {
       tresponder.dispose();
       tw.terminate();
     });
-    const tinit = {
-      type: WASM_THREAD_INIT,
-      pid: opts.shownPid ?? opts.pid,
-      program,
-      argv0: opts.argv0,
-      args: opts.args,
-      env: opts.env,
-      cwd: opts.cwd,
-      sab: tsab,
-      cred: copyCred(process.cred),
-      owners: opts.owners === true,
-      ...opts.ppid !== void 0 ? { ppid: opts.ppid } : {},
-      thread
-    };
-    tw.postMessage(tinit);
+    tw.postMessage(threadInit(opts, program, tsab, process.cred, thread));
   };
   worker.postMessage(
     processInit(opts, sab, process.umask, copyCred(process.cred), lane?.lane),
@@ -12544,7 +12699,9 @@ function spawnWasmProcess(opts) {
     signalMasks: () => process.signalMasks(),
     umask: () => process.umask,
     cred: () => copyCred(process.cred),
-    writesBack: () => opts.program.abi === "wasi" && !done4
+    writesBack: () => opts.program.abi === "wasi" && !done4,
+    times: () => clocks.times(),
+    running: () => clocks.running()
   };
 }
 
@@ -14860,6 +15017,8 @@ var LAYOUT = [
   ["/usr", 493],
   ["/usr/local", 493]
 ];
+var LOAD_SAMPLE_MS = 5e3;
+var LOAD_WINDOWS_MS = [6e4, 3e5, 9e5];
 var encoder3 = new TextEncoder();
 var USERS_MODES = ["off", "report", "enforce"];
 function usersMode(mode = "off") {
@@ -15388,6 +15547,7 @@ var Launcher = class {
     return this.jobs.sessionOf(pgid);
   }
   start(req) {
+    this.sampling();
     if (req.pgid !== void 0 && this.jobs.sessionOf(req.pgid) === void 0) {
       throw fsError("ESRCH", `no process group ${req.pgid}`);
     }
@@ -15428,7 +15588,12 @@ var Launcher = class {
       forker: this.forker(pid, req),
       kill: (target, sig) => this.kill(target, sig, this.credOf(pid), pid),
       writesBack: (target) => this.processes.get(target)?.writesBack() === true,
-      processes: () => ({ boot: this.boot, processes: this.list(this.credOf(pid)) }),
+      processes: () => ({
+        boot: this.boot,
+        processes: this.list(this.credOf(pid)),
+        load: this.loadAverage(),
+        cpu: this.cpuTotal()
+      }),
       sudo: (call, signal) => this.sudo(pid, call, signal),
       openFiles: this.openFiles,
       nodes: this.nodes,
@@ -15462,7 +15627,14 @@ var Launcher = class {
       started: Date.now()
     });
     void handle.exited.then(() => {
+      const spent = handle.times?.();
+      if (spent) this.spent.set(pid, spent);
       this.processes.delete(pid);
+      if (this.processes.size === 0) {
+        clearInterval(this.sampler);
+        this.sampler = void 0;
+        this.idleSince = Date.now();
+      }
       this.settling.settled(pid);
       if (req.ppid === void 0 || this.orphans.delete(pid)) this.forget(pid);
       else this.zombies.add(pid);
@@ -15478,6 +15650,12 @@ var Launcher = class {
   forget(pid) {
     this.jobs.remove(pid);
     this.described.delete(pid);
+    const spent = this.spent.get(pid);
+    if (spent) {
+      this.reapedTimes.utime += spent.utime;
+      this.reapedTimes.stime += spent.stime;
+    }
+    this.spent.delete(pid);
     this.creds.delete(pid);
     this.tags.delete(pid);
     this.granted.delete(pid);
@@ -15486,6 +15664,70 @@ var Launcher = class {
     if (this.zombies.delete(pid)) this.forget(pid);
     else this.orphans.add(pid);
   }
+  load = [0, 0, 0];
+  sampler;
+  reapedTimes = { utime: 0, stime: 0 };
+  idleAt = { wall: this.boot, busy: 0, idle: 0 };
+  cpuTotal(now = Date.now()) {
+    const total = { ...this.reapedTimes };
+    const add = (t) => {
+      total.utime += t?.utime ?? 0;
+      total.stime += t?.stime ?? 0;
+    };
+    for (const handle of this.processes.values()) add(handle.times?.());
+    for (const t of this.spent.values()) add(t);
+    const busy = total.utime + total.stime;
+    const at = this.idleAt;
+    at.idle += Math.max(0, now - at.wall - (busy - at.busy));
+    at.wall = Math.max(at.wall, now);
+    at.busy = Math.max(at.busy, busy);
+    return { ...total, idle: at.idle };
+  }
+  loadAverage() {
+    return this.load;
+  }
+  sampledAt = Date.now();
+  sampleLoad(now = Date.now()) {
+    let running = 0;
+    for (const handle of this.processes.values()) running += handle.running?.() ?? 0;
+    const elapsed = Math.max(LOAD_SAMPLE_MS, now - this.sampledAt);
+    this.sampledAt = Math.max(this.sampledAt, now);
+    this.load = this.load.map((avg, i) => {
+      const window = LOAD_WINDOWS_MS[i];
+      const fresh2 = 1 - Math.exp(-LOAD_SAMPLE_MS / window);
+      return avg * Math.exp(-elapsed / window) + running * fresh2;
+    });
+  }
+  idleSince;
+  sampling() {
+    if (this.sampler) return;
+    if (this.idleSince !== void 0) {
+      const empty = Math.max(0, Date.now() - this.idleSince);
+      this.load = this.load.map(
+        (avg, i) => avg * Math.exp(-empty / LOAD_WINDOWS_MS[i])
+      );
+    }
+    this.sampledAt = Date.now();
+    this.sampler = setInterval(() => this.sampleLoad(), LOAD_SAMPLE_MS);
+    this.sampler.unref?.();
+  }
+  spent = /* @__PURE__ */ new Map();
+  timesAt(pid) {
+    return this.processes.get(pid)?.times?.() ?? this.spent.get(pid);
+  }
+  timesOf(member, members) {
+    let utime = 0;
+    let stime = 0;
+    let timed2 = false;
+    for (let at = member; at; at = members.get(at.execParent ?? -1)) {
+      const t = this.timesAt(at.pid);
+      if (!t) continue;
+      timed2 = true;
+      utime += t.utime;
+      stime += t.stime;
+    }
+    return timed2 ? { utime, stime } : {};
+  }
   list(viewer = ROOT) {
     const members = new Map(this.jobs.list().map((member) => [member.pid, member]));
     const rootOf = (member) => {
@@ -15517,6 +15759,7 @@ var Launcher = class {
         started: (this.described.get(root.pid) ?? described2).started,
         state: this.processes.has(member.pid) ? "S" : "Z",
         memory: this.processes.get(member.pid)?.memory() ?? 0,
+        ...this.timesOf(member, members),
         umask: this.umaskOf(member.pid),
         cred,
         ...this.signalMasksOf(member.pid)