@ai-ecoverse/slicc-kernel 1.122.3 → 1.123.0

package/dist/node.js

@@ -6779,7 +6779,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.122.3" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.123.0" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -12647,17 +12647,28 @@ var FALLBACK_MEMORY = 4 * KIB * KIB * KIB;
 var PID_FILES = ["cmdline", "comm", "stat", "statm", "status"];
 var SYSTEM_FILES = ["loadavg", "meminfo", "stat", "uptime", "version"];
 var SYS_TREE = {
-  kernel: { osrelease: `${OS_RELEASE}
-`, ostype: "Linux\n" }
+  kernel: {
+    osrelease: `${OS_RELEASE}
+`,
+    ostype: "Linux\n",
+    slicc_wasm_memories: (listing) => `${listing.wasm?.live ?? 0} ${listing.wasm?.ceiling ?? 0}
+`
+  }
 };
+function isSysFile(at) {
+  return typeof at === "string" || typeof at === "function";
+}
 function sysEntry(parts2) {
   let at = SYS_TREE;
   for (const part of parts2) {
-    if (typeof at !== "object" || !Object.hasOwn(at, part)) return void 0;
+    if (isSysFile(at) || !Object.hasOwn(at, part)) return void 0;
     at = at[part];
   }
   return at;
 }
+function sysText(file, listing) {
+  return typeof file === "string" ? file : file(listing());
+}
 function commOf(info) {
   const name2 = info.argv[0] ?? "";
   return name2.slice(name2.lastIndexOf("/") + 1).slice(0, 15);
@@ -12893,7 +12904,9 @@ var ProcTree = class {
     }
     if (top === "sys") {
       const entry = sysEntry(parts2.slice(1));
-      if (typeof entry === "string") return { kind: "file", content: () => entry };
+      if (typeof entry === "string" || typeof entry === "function") {
+        return { kind: "file", content: () => sysText(entry, () => this.listing()) };
+      }
       return entry && { kind: "dir", names: () => Object.keys(entry) };
     }
     if (top === "self") {
@@ -19192,6 +19205,7 @@ var WasmProcess = class {
 var WASM_PROCESS_INIT = "wasm-process-init";
 var WASM_PROCESS_EXIT = "wasm-process-exit";
 var WASM_PROCESS_ERROR = "wasm-process-error";
+var WASM_PROCESS_READY = "wasm-process-ready";
 var WASM_THREAD_SPAWN = "wasm-thread-spawn";
 var WASM_THREAD_INIT = "wasm-thread-init";
 var WASM_THREAD_EXIT = "wasm-thread-exit";
@@ -19199,6 +19213,8 @@ var WASM_MAX_THREADS = 256;
 
 // src/kernel/host.ts
 var CRASHED = 70;
+var NO_MEMORY = 126;
+var WASM_OOM = /Cannot allocate Wasm memory|WebAssembly\.Memory\(\): could not allocate memory/;
 var KILL_GRACE_MS = 2e3;
 var KILL_HARD_MS = 5e3;
 var descIds = /* @__PURE__ */ new WeakMap();
@@ -19464,7 +19480,22 @@ function threadInit(opts, program, sab, cred, thread, main) {
 function settleExit(exit, settle, code) {
   void exit.catch(() => void 0).then(() => settle(code & 255));
 }
+function readiness(abi) {
+  const ready2 = Promise.withResolvers();
+  if (abi === "js") ready2.resolve(true);
+  return ready2;
+}
+function outOfMemory(opts, data) {
+  if (data?.type !== WASM_PROCESS_ERROR || !WASM_OOM.test(String(data.message))) return false;
+  if (!opts.onOom?.()) {
+    opts.onError?.(
+      `${opts.argv0}: cannot allocate memory for a new process (too many processes at once)`
+    );
+  }
+  return true;
+}
 function spawnWasmProcess(opts) {
+  const { promise: ready2, resolve: started } = readiness(opts.program.abi);
   const sab = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DEFAULT_WINDOW_BYTES);
   const header4 = new Int32Array(sab, 0, SAB_HEADER_I32);
   const blocked2 = opts.fork?.wasi?.blocked ?? opts.blocked;
@@ -19517,6 +19548,7 @@ function spawnWasmProcess(opts) {
   const finish = (code, sig) => {
     if (done4) return;
     done4 = true;
+    started(true);
     clocks.freeze();
     dying.clear();
     endedBy = sig ?? process2.execTermsig;
@@ -19534,7 +19566,12 @@ function spawnWasmProcess(opts) {
     queueMicrotask(() => finish(...dying.status(code)));
   };
   const handle = (data) => {
-    if (data?.type === WASM_PROCESS_EXIT) {
+    if (data?.type === WASM_PROCESS_READY) {
+      started(true);
+    } else if (outOfMemory(opts, data)) {
+      started(false);
+      finish(NO_MEMORY);
+    } else if (data?.type === WASM_PROCESS_EXIT) {
       finish(...dying.status(data.code));
     } else if (data?.type === WASM_PROCESS_ERROR) {
       if (!dying.ending) opts.onError?.(String(data.message));
@@ -19608,6 +19645,7 @@ function spawnWasmProcess(opts) {
   return {
     pid: opts.pid,
     exited,
+    ready: ready2,
     kill,
     signal,
     termsig: () => endedBy,
@@ -21202,6 +21240,63 @@ var SettlingChildren = class {
   }
 };
 
+// src/kernel/wasm-memories.ts
+var DEFAULT_CEILING = 112;
+var IDLE_MS = 1e4;
+var MARGIN = 16;
+var WasmMemories = class {
+  live = 0;
+  ceiling;
+  waiters = /* @__PURE__ */ new Set();
+  idleMs;
+  constructor(ceiling, idleMs = IDLE_MS) {
+    this.ceiling = ceiling;
+    this.idleMs = idleMs;
+  }
+  count() {
+    return { live: this.live, ceiling: this.ceiling ?? 0 };
+  }
+  ended() {
+    this.live = Math.max(0, this.live - 1);
+    this.progress();
+  }
+  learn() {
+    this.ceiling = Math.max(1, this.live - 1);
+  }
+  near() {
+    return this.ceiling !== void 0 && this.live + MARGIN >= this.ceiling;
+  }
+  async admit() {
+    while (this.ceiling !== void 0 && this.live >= this.ceiling) {
+      if (!await this.changed()) throw new SpawnError("EAGAIN");
+    }
+    this.live += 1;
+    this.progress();
+  }
+  progress() {
+    const waiters = [...this.waiters];
+    this.waiters.clear();
+    for (const wake of waiters) wake();
+  }
+  changed() {
+    return new Promise((resolve2) => {
+      const wake = () => {
+        clearTimeout(timer);
+        resolve2(true);
+      };
+      const timer = setTimeout(() => {
+        this.waiters.delete(wake);
+        resolve2(false);
+      }, this.idleMs);
+      this.waiters.add(wake);
+    });
+  }
+};
+function defaultCeiling() {
+  const node = globalThis.process?.versions?.node;
+  return node === void 0 ? DEFAULT_CEILING : void 0;
+}
+
 // src/mount/driver.ts
 function ownerOf2(req) {
   const owner = {
@@ -23467,6 +23562,9 @@ function withScriptEnv(target, command) {
     ]
   };
 }
+function memoriesOf(given) {
+  return new WasmMemories(given?.ceiling ?? defaultCeiling(), given?.idleMs);
+}
 function childHandle(handle) {
   return {
     pid: handle.pid,
@@ -23538,6 +23636,7 @@ var Launcher = class {
   jobs = new JobTable();
   locks;
   fifos = new FifoTable();
+  memories;
   sems = new SemTable();
   settling = new SettlingChildren((pid) => this.jobs.pgidOf(pid));
   ptys = new PtyTable(
@@ -23591,6 +23690,7 @@ var Launcher = class {
   terminals = 0;
   constructor(options) {
     this.usersMode = usersMode(options.users);
+    this.memories = memoriesOf(options.wasmMemories);
     this.rootFs = options.fs;
     const peers = options.fs.peers?.();
     this.locks = kernelLocks(options.fs.rootName, peers);
@@ -24421,7 +24521,11 @@ var Launcher = class {
     }
     const done4 = this.heldUrl(program);
     try {
-      const handle = this.start({ ...req, cwd, program, argv0: target.argv0, args, env });
+      const handle = await this.admitted(
+        program.abi !== "js",
+        req.fds,
+        (fds, quietOom) => this.start({ ...req, fds, quietOom, cwd, program, argv0: target.argv0, args, env })
+      );
       void handle.exited.finally(done4);
       return handle;
     } catch (err) {
@@ -24465,6 +24569,39 @@ var Launcher = class {
     if (req.tag !== void 0) this.tags.set(pid, req.tag);
     if (req.links !== void 0) this.links.set(pid, req.links);
   }
+  async admitted(wasm, fds, start2) {
+    if (!wasm) return start2(fds);
+    for (; ; ) {
+      await this.memories.admit().catch(async (err) => {
+        await fds.closeAll();
+        throw err;
+      });
+      const counted3 = (handle2) => {
+        void handle2.exited.finally(() => this.memories.ended());
+        return handle2;
+      };
+      if (!this.memories.near()) {
+        try {
+          return counted3(start2(fds));
+        } catch (err) {
+          this.memories.ended();
+          throw err;
+        }
+      }
+      const forked = fds.fork();
+      const handle = await Promise.resolve().then(() => counted3(start2(forked, true))).catch(async (err) => {
+        this.memories.ended();
+        await forked.closeAll();
+        throw err;
+      });
+      const fit = await (handle.ready ?? true);
+      if (fit) {
+        await fds.closeAll();
+        return handle;
+      }
+      await handle.exited;
+    }
+  }
   start(req) {
     this.sampling();
     if (req.pgid !== void 0 && this.jobs.sessionOf(req.pgid) === void 0) {
@@ -24515,6 +24652,10 @@ var Launcher = class {
       ...this.prefixes.length > 0 && !stack.writer ? { readonlyAt: (path) => isProtected(this.prefixes, path) } : {},
       createWorker: this.createWorker,
       onError: req.report,
+      onOom: () => {
+        this.memories.learn();
+        return req.quietOom === true;
+      },
       spawner: this.spawner(pid, req.report),
       forker: this.forker(pid, req),
       kill: (target, sig, info) => this.kill(target, sig, this.credOf(pid), pid, info),
@@ -24523,7 +24664,8 @@ var Launcher = class {
         boot: this.boot,
         processes: this.list(this.credOf(pid)),
         load: this.loadAverage(),
-        cpu: this.cpuTotal()
+        cpu: this.cpuTotal(),
+        wasm: this.memories.count()
       }),
       sudo: (call, signal) => this.sudo(pid, call, signal),
       crontab: (call) => this.crontab(pid, call),
@@ -24860,9 +25002,10 @@ var Launcher = class {
   }
   forker(ppid, parent) {
     const { exec: _exec, pgid: _pgid, group: _group, pid: _pid, scrub: _scrub, ...image } = parent;
-    return async (state, fds) => childHandle(
-      this.start({
+    return async (state, given) => {
+      const fresh2 = (fds, quietOom) => this.start({
         ...image,
+        quietOom,
         cwd: state.cwd ?? parent.cwd,
         fds,
         ppid,
@@ -24873,8 +25016,9 @@ var Launcher = class {
         cred: this.credOf(ppid),
         tag: this.tagOf(ppid),
         links: this.links.get(ppid)
-      })
-    );
+      });
+      return childHandle(await this.admitted(parent.program.abi !== "js", given, fresh2));
+    };
   }
   keySignal(tty, fallback, sig, send) {
     const pgid = this.jobs.tcgetpgrp(tty, fallback);