eyeprolog 1.3.88 → 1.3.89

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.3.88",
+  "version": "1.3.89",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/test/run-all.mjs

@@ -21,7 +21,7 @@ await runStandalone(async (reporter) => {
   runOpenRuleBenchChecks(reporter);
   runArchitecture(reporter);
   runCleanup(reporter);
-  runRegression(reporter);
+  await runRegression(reporter);
   await runPlayground(reporter);
   await runExamples(reporter);
   runBookExamples(reporter);

package/test/run-examples.mjs

@@ -87,13 +87,7 @@ export async function runExamples(reporter = new TestReporter()) {
     .sort();
 
   reporter.section('Examples');
-  const deepTaxonomyIndex = files.indexOf('deep-taxonomy-100000.pl');
-  if (deepTaxonomyIndex >= 0) {
-    await runExampleTasks(files.slice(0, deepTaxonomyIndex + 1), (name, result) => reporter.testResult(name, result), 2);
-    await runExampleTasks(files.slice(deepTaxonomyIndex + 1), (name, result) => reporter.testResult(name, result), 3);
-  } else {
-    await runExampleTasks(files, (name, result) => reporter.testResult(name, result), 3);
-  }
+  await runExampleTasks(files, (name, result) => reporter.testResult(name, result), 3);
   reporter.sectionTotal('examples');
 
   reporter.section('Proof examples');

package/test/run-regression.mjs

@@ -7,6 +7,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
+import { Worker, parentPort, workerData } from 'node:worker_threads';
 import { fileURLToPath } from 'node:url';
 import publicDefaultApi from '../index.js';
 import * as publicApi from '../src/index.js';
@@ -84,13 +85,15 @@ function sourceAtom(value) {
   return `'${String(value).replaceAll('\\', '\\\\').replaceAll("'", "''")}'`;
 }
 
-export function runRegression(reporter = new TestReporter(), requestedSection = null) {
-  const sections = [
+const regressionSections = [
     { key: 'regression', name: 'Regression', cases: regressionCases },
     { key: 'docs', name: 'Documentation sync', cases: documentationSyncCases },
     { key: 'api', name: 'API', cases: apiCases },
     { key: 'white-box', name: 'White-box', cases: whiteBoxCases },
-  ];
+];
+
+export async function runRegression(reporter = new TestReporter(), requestedSection = null) {
+  const sections = regressionSections;
   const selected = requestedSection == null
     ? sections
     : sections.filter((section) => section.key === requestedSection);
@@ -98,16 +101,167 @@ export function runRegression(reporter = new TestReporter(), requestedSection =
     throw new Error(`unknown regression section: ${requestedSection}; expected ${sections.map(({ key }) => key).join(', ')}`);
   }
 
+  const prepared = selected.map((section) => ({ ...section, tests: section.cases() }));
+  const testCount = prepared.reduce((sum, section) => sum + section.tests.length, 0);
+  const parallelism = os.availableParallelism?.() ?? os.cpus().length;
+  // Several cases start bounded-heap child processes, so leave CPU and memory
+  // headroom instead of matching the host's full logical-core count.
+  const workerCount = Math.min(testCount, Math.max(1, Math.min(4, parallelism - 1)));
+  if (workerCount === 1) {
+    withRegressionTemp(() => {
+      for (const section of prepared) runSection(reporter, section.name, section.tests);
+    });
+    return;
+  }
+
+  const results = new Map();
+  let reportSection = 0;
+  let reportTest = 0;
+  reporter.section(prepared[0].name);
+  const reportReady = () => {
+    while (reportSection < prepared.length) {
+      const section = prepared[reportSection];
+      const result = results.get(testKey(section.key, reportTest));
+      if (result == null) return;
+      reporter.testResult(section.tests[reportTest].name, result);
+      reportTest++;
+      if (reportTest !== section.tests.length) continue;
+      reporter.sectionTotal(sectionLabel(section.name), sectionElapsedMs(section, results));
+      reportSection++;
+      reportTest = 0;
+      if (reportSection < prepared.length) reporter.section(prepared[reportSection].name);
+    }
+  };
+  await runRegressionWorkers(prepared, workerCount, results, reportReady);
+}
+
+function withRegressionTemp(runTests) {
   tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'eyeprolog-regression.'));
   tmpCounter = 0;
   try {
-    for (const section of selected) runSection(reporter, section.name, section.cases());
+    return runTests();
   } finally {
     fs.rmSync(tmp, { recursive: true, force: true });
     tmp = null;
   }
 }
 
+async function runRegressionWorkers(sections, workerCount, results, onResult) {
+  const tasks = sections.flatMap((section) => section.tests.map((_, index) => ({
+    sectionKey: section.key,
+    index,
+  })));
+  let nextTask = 0;
+  let completed = 0;
+  let settled = false;
+
+  return new Promise((resolve, reject) => {
+    const workers = Array.from({ length: workerCount }, () => new Worker(new URL(import.meta.url), {
+      workerData: { regressionWorker: true },
+    }));
+
+    const closeWorkers = () => {
+      for (const worker of workers) worker.postMessage({ close: true });
+    };
+    const fail = (error) => {
+      if (settled) return;
+      settled = true;
+      Promise.all(workers.map((worker) => worker.terminate())).finally(() => reject(error));
+    };
+    const assign = (worker) => {
+      if (settled) return;
+      const task = tasks[nextTask++];
+      if (task != null) worker.postMessage(task);
+    };
+
+    for (const worker of workers) {
+      worker.on('message', (message) => {
+        if (settled) return;
+        if (message.ready) {
+          assign(worker);
+          return;
+        }
+        results.set(testKey(message.sectionKey, message.index), {
+          ms: message.ms,
+          error: deserializeWorkerError(message.error),
+          startedAt: message.startedAt,
+          finishedAt: message.finishedAt,
+        });
+        try {
+          onResult();
+        } catch (error) {
+          fail(error);
+          return;
+        }
+        completed++;
+        if (completed === tasks.length) {
+          settled = true;
+          const exits = Promise.all(workers.map((candidate) => new Promise((done, failed) => {
+            candidate.once('exit', done);
+            candidate.once('error', failed);
+          })));
+          closeWorkers();
+          exits.then(() => resolve(results), reject);
+        } else {
+          assign(worker);
+        }
+      });
+      worker.on('error', fail);
+      worker.on('exit', (code) => {
+        if (!settled) fail(new Error(`regression worker exited unexpectedly with status ${code}`));
+      });
+    }
+  });
+}
+
+function testKey(sectionKey, index) {
+  return `${sectionKey}:${index}`;
+}
+
+function sectionElapsedMs(section, results) {
+  const timings = section.tests.map((_, index) => results.get(testKey(section.key, index)));
+  return Math.max(...timings.map(({ finishedAt }) => finishedAt)) -
+    Math.min(...timings.map(({ startedAt }) => startedAt));
+}
+
+function deserializeWorkerError(error) {
+  if (error == null) return null;
+  return Object.assign(new Error(error.message), { stack: error.stack });
+}
+
+function startRegressionWorker() {
+  tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'eyeprolog-regression-worker.'));
+  tmpCounter = 0;
+  const casesBySection = new Map(regressionSections.map((section) => [section.key, section.cases()]));
+  parentPort.on('message', ({ sectionKey, index, close }) => {
+    if (close) {
+      fs.rmSync(tmp, { recursive: true, force: true });
+      tmp = null;
+      parentPort.close();
+      return;
+    }
+    const testCase = casesBySection.get(sectionKey)?.[index];
+    const startedAt = Date.now();
+    const started = performance.now();
+    let error = null;
+    try {
+      if (testCase == null) throw new Error(`unknown regression test ${sectionKey}:${index}`);
+      testCase.run();
+    } catch (caught) {
+      error = { message: caught?.message ?? String(caught), stack: caught?.stack ?? String(caught) };
+    }
+    parentPort.postMessage({
+      sectionKey,
+      index,
+      ms: Math.round(performance.now() - started),
+      startedAt,
+      finishedAt: Date.now(),
+      error,
+    });
+  });
+  parentPort.postMessage({ ready: true });
+}
+
 function regressionCases() {
   return [
     {
@@ -7185,6 +7339,8 @@ function format(value) {
   return typeof value === 'string' ? JSON.stringify(value) : String(value);
 }
 
-if (isMainModule(import.meta.url)) {
+if (workerData?.regressionWorker) {
+  startRegressionWorker();
+} else if (isMainModule(import.meta.url)) {
   await runStandalone((reporter) => runRegression(reporter, process.argv[2] ?? null));
 }

package/test/test-style.mjs

@@ -41,12 +41,12 @@ export class TestReporter {
     this.sectionCount++;
   }
 
-  sectionTotal(label = null) {
+  sectionTotal(label = null, elapsedMs = null) {
     if (this.currentSection == null) return;
 
     const ok = this.ok - this.currentSection.okAtStart;
     const total = this.total - this.currentSection.totalAtStart;
-    const ms = nowMs() - this.currentSection.startedAt;
+    const ms = elapsedMs ?? nowMs() - this.currentSection.startedAt;
     const suite = label ?? defaultSectionLabel(this.currentSection.name);
     this.stdout.write(`${colors.green}OK${colors.reset} ${ok}/${total} ${suite} tests passed ${colors.dim}(${ms} ms)${colors.reset}\n`);
   }