@intelligems/sst 2.49.6-ig.8 → 2.49.8-ig.1

package/runtime/worker-pool.js

@@ -0,0 +1,162 @@
+/**
+ * Bookkeeping for pooled dev workers.
+ *
+ * A pool key groups workers that can serve the same invocations: one key per
+ * function normally, one shared key for every Node function in mono-build
+ * mode. Each worker may hold up to `maxConcurrency` invocations at once, and a
+ * key never holds more than `maxWorkers` live (non-stale) workers, so the
+ * memory a key can consume is bounded by `maxWorkers` isolates.
+ *
+ * This module decides *which* worker serves a request and when a worker is
+ * retired. It never starts or stops threads itself: `onTerminate` is the hook
+ * the owner uses to actually stop the worker.
+ */
+export class WorkerPool {
+    opts;
+    pools = new Map();
+    byID = new Map();
+    constructor(opts) {
+        this.opts = opts;
+    }
+    add(worker) {
+        let pool = this.pools.get(worker.poolKey);
+        if (!pool) {
+            pool = [];
+            this.pools.set(worker.poolKey, pool);
+        }
+        pool.push(worker);
+        this.byID.set(worker.id, worker);
+    }
+    get(id) {
+        return this.byID.get(id);
+    }
+    workersFor(poolKey) {
+        return this.pools.get(poolKey) ?? [];
+    }
+    all() {
+        return [...this.byID.values()];
+    }
+    /** Live workers count toward the cap; stale ones are on their way out. */
+    liveCount(poolKey) {
+        return this.workersFor(poolKey).filter((w) => !w.stale).length;
+    }
+    canCreate(poolKey) {
+        return this.liveCount(poolKey) < this.opts.maxWorkers;
+    }
+    /**
+     * Least-loaded live worker with spare capacity, or undefined. Workers whose
+     * bundle is older than `currentMtime` are retired on the way: idle ones now,
+     * busy ones once they drain.
+     */
+    pick(poolKey, currentMtime) {
+        const pool = this.pools.get(poolKey);
+        if (!pool || pool.length === 0)
+            return undefined;
+        for (const worker of [...pool]) {
+            if (currentMtime &&
+                worker.bundleMtime &&
+                currentMtime > worker.bundleMtime &&
+                !worker.stale) {
+                this.retire(worker, "stale_mtime");
+            }
+        }
+        let best;
+        for (const worker of pool) {
+            if (worker.stale)
+                continue;
+            if (worker.inFlight >= worker.maxConcurrency)
+                continue;
+            if (!best || worker.inFlight < best.inFlight)
+                best = worker;
+        }
+        return best;
+    }
+    /** Hand an invocation to a worker. */
+    checkout(worker, functionID) {
+        if (worker.idleTimer) {
+            clearTimeout(worker.idleTimer);
+            worker.idleTimer = undefined;
+        }
+        worker.inFlight += 1;
+        worker.functionID = functionID;
+    }
+    /**
+     * An invocation finished. Returns what became of the worker: it is gone
+     * (stale and drained), idle (timer armed), or still busy.
+     */
+    checkin(worker) {
+        if (worker.inFlight > 0)
+            worker.inFlight -= 1;
+        if (worker.inFlight > 0)
+            return "busy";
+        if (worker.stale) {
+            this.remove(worker);
+            this.opts.onTerminate(worker, "stale");
+            return "terminated";
+        }
+        worker.idleTimer = setTimeout(() => {
+            worker.idleTimer = undefined;
+            if (worker.inFlight > 0)
+                return;
+            if (!this.byID.has(worker.id))
+                return;
+            this.remove(worker);
+            this.opts.onTerminate(worker, "idle_timeout");
+        }, this.opts.idleTimeoutMs);
+        return "idle";
+    }
+    /**
+     * The code behind `poolKey` changed. Idle workers go now; busy ones are
+     * marked stale and go when they drain. Returns the ids of workers that
+     * were only marked.
+     */
+    invalidate(poolKey, reason) {
+        const marked = [];
+        for (const worker of [...this.workersFor(poolKey)]) {
+            if (worker.inFlight === 0) {
+                this.remove(worker);
+                this.opts.onTerminate(worker, reason);
+            }
+            else {
+                worker.stale = true;
+                marked.push(worker.id);
+            }
+        }
+        return marked;
+    }
+    /** Forget a worker that exited on its own (crash, OOM, self-timeout). */
+    remove(worker) {
+        if (worker.idleTimer) {
+            clearTimeout(worker.idleTimer);
+            worker.idleTimer = undefined;
+        }
+        this.byID.delete(worker.id);
+        const pool = this.pools.get(worker.poolKey);
+        if (!pool)
+            return;
+        const idx = pool.indexOf(worker);
+        if (idx >= 0)
+            pool.splice(idx, 1);
+        if (pool.length === 0)
+            this.pools.delete(worker.poolKey);
+    }
+    stats() {
+        let idle = 0;
+        let inFlight = 0;
+        for (const worker of this.byID.values()) {
+            if (worker.inFlight === 0)
+                idle += 1;
+            inFlight += worker.inFlight;
+        }
+        return { workers: this.byID.size, idle, inFlight };
+    }
+    retire(worker, reason) {
+        if (worker.inFlight === 0) {
+            this.remove(worker);
+            this.opts.onTerminate(worker, reason);
+        }
+        else {
+            worker.stale = true;
+        }
+    }
+}

package/runtime/workers.d.ts

@@ -1,3 +1,4 @@
+import { EventPayload } from "../bus.js";
 declare module "../bus.js" {
     interface Events {
         "worker.started": {
@@ -11,6 +12,8 @@ declare module "../bus.js" {
         "worker.exited": {
             workerID: string;
             functionID: string;
+            /** Set for pooled workers: the id the runtime server keys on. */
+            pooledWorkerID?: string;
         };
         "worker.stdout": {
             workerID: string;
@@ -39,27 +42,45 @@ declare module "../bus.js" {
         };
     }
 }
+interface Worker {
+    workerID: string;
+    functionID: string;
+}
 export declare const useRuntimeWorkers: () => Promise<{
-    fromID(workerID: string): {
-        workerID: string;
-        functionID: string;
-    };
+    fromID(workerID: string): Worker;
     getCurrentRequestID(workerID: string): string | undefined;
+    /**
+     * Who a response belongs to. Pooled workers may hold several requests,
+     * so the request id decides; non-pooled workers are their own AWS worker.
+     */
+    resolveRequest(workerID: string, requestID?: string): {
+        awsWorkerID: string;
+        functionID: string;
+    } | undefined;
     stdout(workerID: string, message: string): void;
     exited(workerID: string): void;
-    onResponse(pooledWorkerID: string): void;
-    getAwsWorkerID(pooledWorkerID: string): string | undefined;
+    onResponse(pooledWorkerID: string, requestID?: string): void;
     isPooled(workerID: string): boolean;
-    subscribe: <Type extends "worker.started" | "worker.stopped" | "worker.exited" | "worker.stdout" | "worker.reused">(type: Type, cb: (payload: import("../bus.js").EventPayload<Type>) => void) => {
+    stats: () => {
+        workers: number;
+        inFlight: number;
+        queued: number;
+    };
+    subscribe: <Type extends "worker.started" | "worker.stopped" | "worker.exited" | "worker.stdout" | "worker.reused">(type: Type, cb: (payload: EventPayload<Type>) => void) => {
         type: keyof import("../bus.js").Events;
         cb: (payload: any) => void;
     };
     /**
-     * Trigger warmup by invoking Lambda functions with warmup payloads.
-     * This sends real requests through the IoT bridge, which naturally creates workers.
-     * @param count Number of workers to warm up (default: 15)
+     * Warm the pool by invoking a Node function with warm pings.
+     *
+     * Each ping is marked as a fan-out *child* (`__WARMER_INVOCATION__ > 1`)
+     * so the app's lambda-warmer preloads its handlers and returns instead of
+     * fanning out to `concurrency` more Lambdas, which is what turned the old
+     * 30 pings into ~900 worker creations. The count is capped at the pool
+     * size, and pings go through the normal pool path, so warmup can never
+     * hold more isolates than steady state.
      */
-    triggerWarmup(count?: number): Promise<{
+    triggerWarmup(count: number): Promise<{
         warmed: number;
         elapsed?: undefined;
     } | {
@@ -67,3 +88,4 @@ export declare const useRuntimeWorkers: () => Promise<{
         elapsed: number;
     }>;
 }>;
+export {};