@ai-ecoverse/slicc-kernel 1.124.1 → 1.124.2

package/README.md

@@ -942,11 +942,14 @@ The kernel writes `/etc/passwd` and `/etc/group` when it starts (see [Users](#us
 ### How many processes at once
 
 In a browser every process worker of the page shares one renderer. V8 reserves about 8 GiB of address space for each 32-bit wasm memory, whatever its declared maximum, and its sandbox holds about 1 TiB. So a page runs about 125 wasm processes (or programs that own a wasm memory) at once, counting everything in the renderer (#970). Node has no such ceiling, and neither does Linux. The kernel keeps processes inside that ceiling:
-- **The ceiling:** 112 by default in a browser and none in Node. It's the kernel's count of live wasm processes, with the kernel's other wasm memories in the page left outside it. When an instantiation runs out of memory anyway, the kernel learns the real ceiling at that moment (the live count minus one), and that learned value wins over the default.
+- **The ceiling:** 112 by default in a browser and none in Node. It's the kernel's count of live wasm processes, with the kernel's other wasm memories in the page left outside it. When an instantiation runs out of memory anyway, the kernel learns the real ceiling at that moment (the live count minus one), and that learned value wins over the default. A learned ceiling is never below 16, since an OOM at a low count means something outside it (another tab in the same renderer) filled the renderer. It's raised by 8 for each minute without another OOM, back to the default.
 - **Admission:** a spawn, fork, exec or `kernel.run` at the ceiling waits for another process to exit. It keeps waiting as long as processes exit or are admitted, and fails with `EAGAIN` only after 10 s with neither. A long `make -j` or `xargs -P` therefore queues, and a pipeline that needs more live processes than the ceiling fails cleanly. bash's own retry on a fork's `EAGAIN` (`fork: retry: Resource temporarily unavailable`) handles the rest.
 - **Close to the ceiling** (within 16 of it), the kernel waits for each new process to finish instantiating before the spawn returns. If it ran out of memory, the kernel starts it again, quietly, once there's room, so the caller sees no failure.
 - **The rare residual case:** a process that fails to instantiate with nobody waiting on it, which happens only when something outside the count fills the renderer. It ends with status 126 and `<program>: cannot allocate memory for a new process (too many processes at once)` on its stderr, never a JS `RangeError`.
-- **`/proc/sys/kernel/slicc_wasm_memories`** reads `<live> <ceiling>` (the ceiling 0 for none).
+- **Below a learned ceiling,** a process that still runs out of memory is started again once another process exits, and the spawn fails with `EAGAIN` after 10 s with none.
+- **`/proc/sys/kernel/slicc_wasm_memories`** reads `<live> <ceiling> <source>`. The source is `default`, `learned`, or `none` (with the ceiling 0).
+
+`/proc/sys/kernel/slicc_shared_root` reads `1` while another kernel shares the root (a tab, or a second kernel in the page) and `0` otherwise. A peer's tab that closes is noticed when this kernel next writes to a shared file, at most every 30 s, so the value can stay `1` for a while after a peer has gone.
 
 ### Metadata
 

package/dist/kernel-worker.js

@@ -6565,7 +6565,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.124.1" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.124.2" : "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
@@ -12721,7 +12721,9 @@ var SYS_TREE = {
     osrelease: `${OS_RELEASE}
 `,
     ostype: "Linux\n",
-    slicc_wasm_memories: (listing) => `${listing.wasm?.live ?? 0} ${listing.wasm?.ceiling ?? 0}
+    slicc_wasm_memories: (listing) => `${listing.wasm?.live ?? 0} ${listing.wasm?.ceiling ?? 0} ${listing.wasm?.source ?? "none"}
+`,
+    slicc_shared_root: (listing) => `${listing.peers ?? 0}
 `
   }
 };
@@ -21926,37 +21928,65 @@ var SettlingChildren = class {
 
 // src/kernel/wasm-memories.ts
 var DEFAULT_CEILING = 112;
+var CEILING_FLOOR = 16;
 var IDLE_MS = 1e4;
 var MARGIN = 16;
+var DECAY_MS = 6e4;
+var DECAY_STEP = 8;
 var WasmMemories = class {
   live = 0;
-  ceiling;
+  learned;
   waiters = /* @__PURE__ */ new Set();
+  base;
   idleMs;
-  constructor(ceiling, idleMs = IDLE_MS) {
-    this.ceiling = ceiling;
+  now;
+  constructor(ceiling, idleMs = IDLE_MS, now = Date.now) {
+    this.base = ceiling;
     this.idleMs = idleMs;
+    this.now = now;
+  }
+  ceiling() {
+    const learned = this.learned;
+    if (!learned) return this.base;
+    const steps = Math.floor((this.now() - learned.at) / DECAY_MS);
+    const raised = learned.ceiling + steps * DECAY_STEP;
+    if (raised < (this.base ?? DEFAULT_CEILING)) return raised;
+    this.learned = void 0;
+    return this.base;
   }
   count() {
-    return { live: this.live, ceiling: this.ceiling ?? 0 };
+    const ceiling = this.ceiling();
+    const source = this.learned ? "learned" : ceiling === void 0 ? "none" : "default";
+    return { live: this.live, ceiling: ceiling ?? 0, source };
   }
   ended() {
     this.live = Math.max(0, this.live - 1);
     this.progress();
   }
   learn() {
-    this.ceiling = Math.max(1, this.live - 1);
+    const top = this.base ?? DEFAULT_CEILING;
+    this.learned = {
+      ceiling: Math.min(top, Math.max(CEILING_FLOOR, this.live - 1)),
+      at: this.now()
+    };
   }
   near() {
-    return this.ceiling !== void 0 && this.live + MARGIN >= this.ceiling;
+    const ceiling = this.ceiling();
+    return ceiling !== void 0 && this.live + MARGIN >= ceiling;
   }
   async admit() {
-    while (this.ceiling !== void 0 && this.live >= this.ceiling) {
+    for (let ceiling = this.ceiling(); ceiling !== void 0 && this.live >= ceiling; ) {
       if (!await this.changed()) throw new SpawnError("EAGAIN");
+      ceiling = this.ceiling();
     }
     this.live += 1;
     this.progress();
   }
+  async refused() {
+    const ceiling = this.ceiling();
+    if (ceiling === void 0 || this.live >= ceiling) return;
+    if (!await this.changed()) throw new SpawnError("EAGAIN");
+  }
   progress() {
     const waiters = [...this.waiters];
     this.waiters.clear();
@@ -25217,6 +25247,10 @@ var Launcher = class {
         return handle;
       }
       await handle.exited;
+      await this.memories.refused().catch(async (err) => {
+        await fds.closeAll();
+        throw err;
+      });
     }
   }
   start(req) {
@@ -25282,7 +25316,8 @@ var Launcher = class {
         processes: this.list(this.credOf(pid)),
         load: this.loadAverage(),
         cpu: this.cpuTotal(),
-        wasm: this.memories.count()
+        wasm: this.memories.count(),
+        peers: Number(this.locks.shared?.() === true)
       }),
       sudo: (call, signal) => this.sudo(pid, call, signal),
       crontab: (call) => this.crontab(pid, call),