fm-bench 0.7.1 → 0.7.2

package/bin/fm-bench.js

@@ -4,18 +4,29 @@ import { killActiveChildren } from '../src/process.js';
 
 // Terminate any in-flight `fm` child process before exiting, then use the
 // conventional 128 + signal exit code. A second signal exits immediately.
-let interrupting = false;
+let signalsReceived = 0;
+let interrupted = false;
 for (const [signal, exitCode] of [['SIGINT', 130], ['SIGTERM', 143]]) {
   process.on(signal, () => {
+    signalsReceived += 1;
+    interrupted = true;
+    // Carry the status on the process too, so the code survives even if the
+    // exit below is preempted.
+    process.exitCode = exitCode;
     const killed = killActiveChildren(signal);
-    if (interrupting) process.exit(exitCode);
-    interrupting = true;
-    const graceMs = killed > 0 ? 500 : 0;
-    setTimeout(() => process.exit(exitCode), graceMs).unref();
+    if (signalsReceived > 1 || killed === 0) process.exit(exitCode);
+    // Deliberately not unref'd: this timer performs the exit after giving the
+    // killed children a moment to be reaped.
+    setTimeout(() => process.exit(exitCode), 500);
   });
 }
 
 runCli(process.argv.slice(2)).catch((error) => {
+  if (interrupted) {
+    // The user asked to stop; a follow-up benchmark error is noise.
+    process.exitCode = typeof error?.exitCode === 'number' ? error.exitCode : 1;
+    return;
+  }
   const message = error?.message || String(error);
   console.error(`fm-bench: ${message}`);
   process.exitCode = typeof error?.exitCode === 'number' ? error.exitCode : 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fm-bench",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "Dynamic benchmark CLI for Apple's fm command on macOS 27+.",
   "type": "module",
   "bin": {
@@ -26,9 +26,15 @@
   },
   "keywords": [
     "apple",
+    "apple-intelligence",
+    "apple-silicon",
     "foundation-models",
     "fm",
+    "llm",
     "benchmark",
+    "benchmarking",
+    "latency",
+    "throughput",
     "macos",
     "cli"
   ],

package/src/bench.js

@@ -381,13 +381,22 @@ async function runSingleBenchmark(context) {
 
 async function runLimited(items, concurrency, worker, options = {}) {
   let nextIndex = 0;
+  // fail-fast stops admitting new work; calls already in flight are allowed to
+  // finish so no `fm` process is abandoned mid-run.
+  let cancelled = false;
   const waitForSlot = createPacer(options.requestRate, options.rampUpMs);
   const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
-    while (nextIndex < items.length) {
+    while (!cancelled && nextIndex < items.length) {
       const index = nextIndex;
       nextIndex += 1;
       await waitForSlot(index);
-      await worker(items[index]);
+      if (cancelled) break;
+      try {
+        await worker(items[index]);
+      } catch (error) {
+        cancelled = true;
+        throw error;
+      }
     }
   });
   await Promise.all(workers);