Set benchmark timeout

bench/src/server/queue.ts

@@ -92,14 +92,17 @@ export class BenchmarkQueue extends EventEmitter {
       }
       pending.completedAt = Date.now();
       this.emit("failed", pending);
+    } finally {
+      // Ensure isProcessing is always reset
+      this.isProcessing = false;
+      // Process next item
+      setImmediate(() => this.processQueue());
     }
-
-    this.isProcessing = false;
-    // Process next item
-    setImmediate(() => this.processQueue());
   }
 
   private async runBenchmark(request: BenchmarkRequest): Promise<BenchmarkResult> {
+    const BENCHMARK_TIMEOUT = parseInt(process.env.BENCHMARK_TIMEOUT || String(10 * 60 * 1000), 10); // 10 minutes default
+
     if (request.platform === "node") {
       // Use spawn instead of dynamic import to avoid import.meta.url issues
       const { spawn } = await import("child_process");
@@ -121,6 +124,19 @@ export class BenchmarkQueue extends EventEmitter {
         const proc = spawn("tsx", args, { cwd: process.cwd() });
         let stdout = "";
         let stderr = "";
+        let isResolved = false;
+
+        // Timeout handler
+        const timeoutId = setTimeout(() => {
+          if (!isResolved) {
+            isResolved = true;
+            logger.error(`[Queue] Benchmark ${request.id} timed out after ${BENCHMARK_TIMEOUT / 1000}s`);
+            proc.kill('SIGTERM');
+            // Give it 5 seconds to clean up, then force kill
+            setTimeout(() => proc.kill('SIGKILL'), 5000);
+            reject(new Error(`Benchmark timed out after ${BENCHMARK_TIMEOUT / 1000}s`));
+          }
+        }, BENCHMARK_TIMEOUT);
 
         proc.stdout.on("data", (data) => {
           stdout += data.toString();
@@ -130,23 +146,42 @@ export class BenchmarkQueue extends EventEmitter {
           stderr += data.toString();
         });
 
-        proc.on("close", (code) => {
-          if (code !== 0) {
-            reject(new Error(`Benchmark failed with code ${code}: ${stderr}`));
-            return;
+        // Error handler for spawn failures
+        proc.on("error", (error) => {
+          if (!isResolved) {
+            isResolved = true;
+            clearTimeout(timeoutId);
+            reject(new Error(`Failed to spawn process: ${error.message}`));
           }
+        });
+
+        proc.on("close", (code, signal) => {
+          if (!isResolved) {
+            isResolved = true;
+            clearTimeout(timeoutId);
+
+            if (signal) {
+              reject(new Error(`Benchmark killed by signal ${signal}`));
+              return;
+            }
+
+            if (code !== 0) {
+              reject(new Error(`Benchmark failed with code ${code}: ${stderr}`));
+              return;
+            }
 
-          // Extract JSON from stdout (last JSON object)
-          const jsonMatch = stdout.match(/\{[\s\S]*"platform"[\s\S]*\}/);
-          if (jsonMatch) {
-            try {
-              const result = JSON.parse(jsonMatch[0]);
-              resolve(result);
-            } catch (e) {
-              reject(new Error(`Failed to parse benchmark result: ${e}`));
+            // Extract JSON from stdout (last JSON object)
+            const jsonMatch = stdout.match(/\{[\s\S]*"platform"[\s\S]*\}/);
+            if (jsonMatch) {
+              try {
+                const result = JSON.parse(jsonMatch[0]);
+                resolve(result);
+              } catch (e) {
+                reject(new Error(`Failed to parse benchmark result: ${e}`));
+              }
+            } else {
+              reject(new Error("No benchmark result found in output"));
             }
-          } else {
-            reject(new Error("No benchmark result found in output"));
           }
         });
       });
@@ -174,6 +209,19 @@ export class BenchmarkQueue extends EventEmitter {
         const proc = spawn("tsx", args, { cwd: process.cwd() });
         let stdout = "";
         let stderr = "";
+        let isResolved = false;
+
+        // Timeout handler
+        const timeoutId = setTimeout(() => {
+          if (!isResolved) {
+            isResolved = true;
+            logger.error(`[Queue] Benchmark ${request.id} timed out after ${BENCHMARK_TIMEOUT / 1000}s`);
+            proc.kill('SIGTERM');
+            // Give it 5 seconds to clean up, then force kill
+            setTimeout(() => proc.kill('SIGKILL'), 5000);
+            reject(new Error(`Benchmark timed out after ${BENCHMARK_TIMEOUT / 1000}s`));
+          }
+        }, BENCHMARK_TIMEOUT);
 
         proc.stdout.on("data", (data) => {
           stdout += data.toString();
@@ -183,23 +231,42 @@ export class BenchmarkQueue extends EventEmitter {
           stderr += data.toString();
         });
 
-        proc.on("close", (code) => {
-          if (code !== 0) {
-            reject(new Error(`Benchmark failed with code ${code}: ${stderr}`));
-            return;
+        // Error handler for spawn failures
+        proc.on("error", (error) => {
+          if (!isResolved) {
+            isResolved = true;
+            clearTimeout(timeoutId);
+            reject(new Error(`Failed to spawn process: ${error.message}`));
           }
+        });
+
+        proc.on("close", (code, signal) => {
+          if (!isResolved) {
+            isResolved = true;
+            clearTimeout(timeoutId);
+
+            if (signal) {
+              reject(new Error(`Benchmark killed by signal ${signal}`));
+              return;
+            }
+
+            if (code !== 0) {
+              reject(new Error(`Benchmark failed with code ${code}: ${stderr}`));
+              return;
+            }
 
-          // Extract JSON from stdout (last JSON object)
-          const jsonMatch = stdout.match(/\{[\s\S]*"platform"[\s\S]*\}/);
-          if (jsonMatch) {
-            try {
-              const result = JSON.parse(jsonMatch[0]);
-              resolve(result);
-            } catch (e) {
-              reject(new Error(`Failed to parse benchmark result: ${e}`));
+            // Extract JSON from stdout (last JSON object)
+            const jsonMatch = stdout.match(/\{[\s\S]*"platform"[\s\S]*\}/);
+            if (jsonMatch) {
+              try {
+                const result = JSON.parse(jsonMatch[0]);
+                resolve(result);
+              } catch (e) {
+                reject(new Error(`Failed to parse benchmark result: ${e}`));
+              }
+            } else {
+              reject(new Error("No benchmark result found in output"));
             }
-          } else {
-            reject(new Error("No benchmark result found in output"));
           }
         });
       });

bench/src/web/cli.ts

@@ -45,70 +45,104 @@ async function main() {
   console.log(`Headed     : ${headed}`);
   console.log(`Timeout    : ${PLAYWRIGHT_TIMEOUT / 1000}s (navigation: ${NAVIGATION_TIMEOUT / 1000}s)`);
 
-  // Start Vite dev server
-  const server = await createServer({
-    configFile: false, // Don't load vite.config.ts to avoid permission issues in read-only filesystems
-    server: {
-      port: 5173,
-      strictPort: false,
-    },
-    logLevel: "error",
-    cacheDir: process.env.VITE_CACHE_DIR || "node_modules/.vite",
-  });
-
-  await server.listen();
-
-  const port = server.config.server.port || 5173;
-  const url = `http://localhost:${port}`;
-
-  console.log(`Vite server started at ${url}`);
-
-  let browser: Browser;
-
-  // Build args based on mode
-  const args = device === "wasm"
-    ? [
-        "--disable-gpu",
-        "--disable-software-rasterizer",
-        // Increase WASM memory limits for large models
-        "--js-flags=--max-old-space-size=8192",
-      ]
-    : [
-        // Official WebGPU flags from Chrome team
-        // https://developer.chrome.com/blog/supercharge-web-ai-testing#enable-webgpu
-        "--enable-unsafe-webgpu",
-        "--enable-features=Vulkan",
-      ];
-
-  // Add headless-specific flags only in headless mode
-  if (!headed && device !== "wasm") {
-    args.push(
-      "--no-sandbox",
-      "--headless=new",
-      "--use-angle=vulkan",
-      "--disable-vulkan-surface"
-    );
-  }
+  let browser: Browser | undefined;
+  let server: Awaited<ReturnType<typeof createServer>> | undefined;
+  let cleanupHandled = false;
+
+  const cleanup = async () => {
+    if (cleanupHandled) return;
+    cleanupHandled = true;
+
+    console.log('\nCleaning up...');
+    try {
+      if (browser) {
+        await browser.close();
+      }
+    } catch (e) {
+      console.error("Failed to close browser:", e);
+    }
 
-  const launchOptions = {
-    headless: !headed,
-    args,
+    try {
+      if (server) {
+        await server.close();
+      }
+    } catch (e) {
+      console.error("Failed to close Vite server:", e);
+    }
   };
 
-  switch (browserType) {
-    case "firefox":
-      browser = await firefox.launch(launchOptions);
-      break;
-    case "webkit":
-      browser = await webkit.launch(launchOptions);
-      break;
-    case "chromium":
-    default:
-      browser = await chromium.launch(launchOptions);
-      break;
-  }
+  // Handle termination signals
+  process.on('SIGTERM', async () => {
+    await cleanup();
+    process.exit(0);
+  });
+  process.on('SIGINT', async () => {
+    await cleanup();
+    process.exit(0);
+  });
 
   try {
+    // Start Vite dev server
+    server = await createServer({
+      configFile: false, // Don't load vite.config.ts to avoid permission issues in read-only filesystems
+      server: {
+        port: 5173,
+        strictPort: false,
+      },
+      logLevel: "error",
+      cacheDir: process.env.VITE_CACHE_DIR || "node_modules/.vite",
+    });
+
+    await server.listen();
+
+    const port = server.config.server.port || 5173;
+    const url = `http://localhost:${port}`;
+
+    console.log(`Vite server started at ${url}`);
+
+    // Build args based on mode
+    const args = device === "wasm"
+      ? [
+          "--disable-gpu",
+          "--disable-software-rasterizer",
+          // Increase WASM memory limits for large models
+          "--js-flags=--max-old-space-size=8192",
+        ]
+      : [
+          // Official WebGPU flags from Chrome team
+          // https://developer.chrome.com/blog/supercharge-web-ai-testing#enable-webgpu
+          "--enable-unsafe-webgpu",
+          "--enable-features=Vulkan",
+        ];
+
+    // Add headless-specific flags only in headless mode
+    if (!headed && device !== "wasm") {
+      args.push(
+        "--no-sandbox",
+        "--headless=new",
+        "--use-angle=vulkan",
+        "--disable-vulkan-surface"
+      );
+    }
+
+    const launchOptions = {
+      headless: !headed,
+      args,
+    };
+
+    switch (browserType) {
+      case "firefox":
+        browser = await firefox.launch(launchOptions);
+        break;
+      case "webkit":
+        browser = await webkit.launch(launchOptions);
+        break;
+      case "chromium":
+      default:
+        browser = await chromium.launch(launchOptions);
+        break;
+    }
+
     const context = await browser.newContext();
     const page = await context.newPage();
 
@@ -202,8 +236,7 @@ async function main() {
     }
 
   } finally {
-    await browser.close();
-    await server.close();
+    await cleanup();
   }
 }