@andersbakken/fisk 4.0.55 → 4.0.56

package/daemon/fisk-daemon.js

@@ -42,6 +42,12 @@ const Constants = {
     get JSON() {
         return 5;
     },
+    get AcquireSlot() {
+        return 6;
+    },
+    get ReleaseLocalSlot() {
+        return 7;
+    },
     // daemon codes
     get CppSlotAcquired() {
         return 10;
@@ -51,6 +57,9 @@ const Constants = {
     },
     get JSONResponse() {
         return 12;
+    },
+    get LocalSlotAcquired() {
+        return 13;
     }
 };
 
@@ -208,6 +217,12 @@ class Compile extends EventEmitter__default["default"] {
                     case Constants.ReleaseCompileSlot:
                         emit("releaseCompileSlot");
                         continue;
+                    case Constants.AcquireSlot:
+                        emit("acquireSlot");
+                        continue;
+                    case Constants.ReleaseLocalSlot:
+                        emit("releaseLocalSlot");
+                        continue;
                     case Constants.JSON:
                         if (available < 5) {
                             break;
@@ -3334,6 +3349,16 @@ class Slots extends EventEmitter__default["default"] {
             console.log("Slots created", this.toString());
         }
     }
+    tryAcquire(id, data) {
+        if (this.used.size < this.count) {
+            this.used.set(id, data);
+            if (this.debug) {
+                console.log("tryAcquire succeeded", id, data, this.toString());
+            }
+            return true;
+        }
+        return false;
+    }
     acquire(id, data, cb) {
         if (this.used.size < this.count) {
             this.used.set(id, data);
@@ -4118,6 +4143,8 @@ Options:
   --socket=PATH          Unix socket path (default: ~/.cache/fisk/daemon/socket)
   --cpp-slots=N          Preprocess slot count (default: cpus * 2)
   --slots=N              Compile slot count (default: cpus)
+  --local-slots=N        Local compile slot count (default: 0, disabled)
+  --local-slots-max-load=N  Max system load average (1-min) to allow local compiles (default: 0, no limit)
   --cache-dir=PATH       Cache directory (default: ~/.cache/fisk/daemon)
 
 Config files: ~/.config/fisk/daemon.conf, /etc/xdg/fisk/daemon.conf
@@ -4153,15 +4180,34 @@ server.on("error", (err) => {
 });
 const cppSlots = new Slots(option.int("cpp-slots", Math.max(os__default["default"].cpus().length * 2, 1)), "cpp", debug);
 const compileSlots = new Slots(option.int("slots", Math.max(os__default["default"].cpus().length, 1)), "compile", debug);
+const localSlotCount = option.int("local-slots", 0);
+const localSlots = new Slots(localSlotCount, "local", debug);
+const localSlotsMaxLoad = option("local-slots-max-load") || 0;
+function canAcquireLocalSlot() {
+    if (localSlotCount <= 0) {
+        return false;
+    }
+    if (localSlotsMaxLoad > 0) {
+        const loadAvg = os__default["default"].loadavg()[0];
+        if (loadAvg > localSlotsMaxLoad) {
+            if (debug) {
+                console.log(`Local slot denied: load ${loadAvg.toFixed(2)} > max ${localSlotsMaxLoad}`);
+            }
+            return false;
+        }
+    }
+    return true;
+}
 server.on("compile", (compile) => {
     compile.on("dumpSlots", () => {
-        const ret = { cpp: cppSlots.dump(), compile: compileSlots.dump() };
+        const ret = { cpp: cppSlots.dump(), compile: compileSlots.dump(), local: localSlots.dump() };
         if (debug) {
             console.log("sending dump", ret);
         }
         compile.send(ret);
     });
     let requestedCppSlot = false;
+    let requestedLocalSlot = false;
     compile.on("acquireCppSlot", () => {
         if (debug) {
             console.log("acquireCppSlot");
@@ -4205,6 +4251,38 @@ server.on("compile", (compile) => {
             compileSlots.release(compile.id);
         }
     });
+    compile.on("acquireSlot", () => {
+        if (debug) {
+            console.log("acquireSlot");
+        }
+        if (canAcquireLocalSlot() && localSlots.tryAcquire(compile.id, { pid: compile.pid })) {
+            if (debug) {
+                console.log("acquireSlot -> local slot granted");
+            }
+            requestedLocalSlot = true;
+            compile.send(Constants.LocalSlotAcquired);
+        }
+        else {
+            if (debug) {
+                console.log("acquireSlot -> falling back to cpp slot");
+            }
+            assert__default["default"](!requestedCppSlot);
+            requestedCppSlot = true;
+            cppSlots.acquire(compile.id, { pid: compile.pid }, () => {
+                compile.send(Constants.CppSlotAcquired);
+            });
+        }
+    });
+    compile.on("releaseLocalSlot", () => {
+        if (debug) {
+            console.log("releaseLocalSlot");
+        }
+        assert__default["default"](requestedLocalSlot);
+        if (requestedLocalSlot) {
+            requestedLocalSlot = false;
+            localSlots.release(compile.id);
+        }
+    });
     compile.on("error", (err) => {
         if (debug) {
             console.error("Got error from fiskc", compile.id, compile.pid, err);
@@ -4217,6 +4295,10 @@ server.on("compile", (compile) => {
             requestedCompileSlot = false;
             compileSlots.release(compile.id);
         }
+        if (requestedLocalSlot) {
+            requestedLocalSlot = false;
+            localSlots.release(compile.id);
+        }
     });
     compile.on("end", () => {
         if (debug) {
@@ -4230,6 +4312,10 @@ server.on("compile", (compile) => {
             requestedCompileSlot = false;
             compileSlots.release(compile.id);
         }
+        if (requestedLocalSlot) {
+            requestedLocalSlot = false;
+            localSlots.release(compile.id);
+        }
     });
 });
 process.on("exit", () => {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@andersbakken/fisk",
-    "version": "4.0.55",
+    "version": "4.0.56",
     "description": "Fisk, a distributed compile system",
     "scripts": {
         "lint": "eslint . --ext .ts",