eyeprolog 1.6.29 → 1.6.30

package/package.json

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

package/test/parallel-tasks.mjs

@@ -0,0 +1,113 @@
+// A small ordered worker pool for the suites that do the same work once per
+// file: run every example, prove every example, check every packaged proof.
+//
+// Results are reported in task order however the workers finish, so a parallel
+// suite numbers its tests exactly as the sequential one did and a failure still
+// stops the run at the same test. Each suite compares inside its worker, so
+// only a name, an elapsed time, an optional failure, and a small plain-data
+// value cross the thread boundary.
+import os from 'node:os';
+import { Worker } from 'node:worker_threads';
+
+export async function runTasksInParallel({
+  names,
+  workerUrl,
+  workerData,
+  message = {},
+  maxWorkers,
+  runLocally,
+  onResult,
+}) {
+  if (names.length === 0) return;
+  const parallelism = os.availableParallelism?.() ?? os.cpus().length;
+  const workerCount = Math.min(names.length, Math.max(1, Math.min(maxWorkers, parallelism - 1)));
+  if (workerCount === 1) {
+    for (const name of names) {
+      const startedAt = performance.now();
+      try {
+        const value = runLocally(name) ?? null;
+        onResult(name, { ms: Math.round(performance.now() - startedAt), value });
+      } catch (error) {
+        onResult(name, { ms: Math.round(performance.now() - startedAt), error });
+      }
+    }
+    return;
+  }
+
+  const completedResults = new Map();
+  let nextTask = 0;
+  let nextReport = 0;
+  let completed = 0;
+  let settled = false;
+
+  await new Promise((resolve, reject) => {
+    const workers = Array.from({ length: workerCount }, () => new Worker(workerUrl, { workerData }));
+
+    const stopWorkers = () => Promise.all(workers.map((worker) => worker.terminate()));
+
+    const fail = (error) => {
+      if (settled) return;
+      settled = true;
+      stopWorkers().finally(() => reject(error));
+    };
+
+    const finish = () => {
+      if (settled || completed !== names.length || nextReport !== names.length) return;
+      settled = true;
+      stopWorkers().then(() => resolve(), reject);
+    };
+
+    const reportReady = () => {
+      try {
+        while (completedResults.has(nextReport)) {
+          const result = completedResults.get(nextReport);
+          completedResults.delete(nextReport);
+          onResult(names[nextReport], result);
+          nextReport++;
+        }
+      } catch (error) {
+        fail(error);
+      }
+    };
+
+    const assign = (worker) => {
+      if (nextTask >= names.length || settled) return;
+      worker.postMessage({ ...message, id: nextTask, name: names[nextTask++] });
+    };
+
+    for (const worker of workers) {
+      worker.on('message', ({ id, ms, error, value }) => {
+        if (settled) return;
+        completedResults.set(id, {
+          ms,
+          value: value ?? null,
+          error: error == null ? null : Object.assign(new Error(error.message), { stack: error.stack }),
+        });
+        completed++;
+        reportReady();
+        assign(worker);
+        finish();
+      });
+      worker.on('error', fail);
+      assign(worker);
+    }
+  });
+}
+
+// The worker side of the same protocol. `runTask` receives the posted message
+// and may return a plain-data value for the pool to hand back with the result.
+export function serveTasks(parentPort, runTask) {
+  parentPort.on('message', (task) => {
+    const startedAt = performance.now();
+    try {
+      const value = runTask(task) ?? null;
+      parentPort.postMessage({ id: task.id, ms: Math.round(performance.now() - startedAt), error: null, value });
+    } catch (error) {
+      parentPort.postMessage({
+        id: task.id,
+        ms: Math.round(performance.now() - startedAt),
+        error: { message: error?.message ?? String(error), stack: error?.stack ?? String(error) },
+      });
+    }
+  });
+}

package/test/run-all.mjs

@@ -35,6 +35,6 @@ await runStandalone(async (reporter) => {
   await runRegression(reporter);
   await runPlayground(reporter);
   await runExamples(reporter);
-  runProofChecking(reporter);
+  await runProofChecking(reporter);
   runBookExamples(reporter);
 });

package/test/run-examples.mjs

@@ -2,13 +2,13 @@
 // Example-output test runner.
 // It compares examples byte-for-byte against golden output so answer and proof changes cannot silently alter results.
 import fs from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
-import { Worker, isMainThread, parentPort, workerData } from 'node:worker_threads';
+import { isMainThread, parentPort, workerData } from 'node:worker_threads';
 import { Program, run } from '../src/index.js';
 import { fileURLToPath } from 'node:url';
 import { TestReporter, isMainModule, runStandalone } from './test-style.mjs';
+import { runTasksInParallel, serveTasks } from './parallel-tasks.mjs';
 import { goalsInProgramOrder } from './goal-metadata.mjs';
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)));
@@ -31,107 +31,39 @@ export async function runExamples(reporter = new TestReporter()) {
     .sort();
 
   reporter.section('Examples');
-  await runExampleTasks(files, (name, result) => reporter.testResult(name, result), 3);
+  await runExampleTasks(files, 'output', reporter);
   reporter.sectionTotal('examples');
 
+  // Proving an example costs several times what running it does, so this is
+  // the longer of the two passes over the same corpus. It is the same work per
+  // program and the same isolation, so it goes through the same worker pool.
   reporter.section('Proof examples');
-  for (const name of proofExamples) reporter.test(name, () => runProofExample(name));
+  await runExampleTasks(proofExamples, 'proof', reporter);
   reporter.sectionTotal('proof examples');
 }
 
-
-async function runExampleTasks(tasks, onResult, maxWorkers) {
-  if (tasks.length === 0) return;
-  const parallelism = os.availableParallelism?.() ?? os.cpus().length;
-  const workerCount = Math.min(tasks.length, Math.max(1, Math.min(maxWorkers, parallelism - 1)));
-  if (workerCount === 1) {
-    for (const name of tasks) {
-      const startedAt = performance.now();
-      try {
-        runExample(name);
-        onResult(name, { ms: Math.round(performance.now() - startedAt) });
-      } catch (error) {
-        onResult(name, { ms: Math.round(performance.now() - startedAt), error });
-      }
-    }
-    return;
-  }
-
-  const completedResults = new Map();
-  let nextTask = 0;
-  let nextReport = 0;
-  let completed = 0;
-  let settled = false;
-
-  await new Promise((resolve, reject) => {
-    const workers = Array.from({ length: workerCount }, () => new Worker(new URL(import.meta.url), {
-      workerData: { exampleWorker: true },
-    }));
-
-    const stopWorkers = () => Promise.all(workers.map((worker) => worker.terminate()));
-
-    const fail = (error) => {
-      if (settled) return;
-      settled = true;
-      stopWorkers().finally(() => reject(error));
-    };
-
-    const finish = () => {
-      if (settled || completed !== tasks.length || nextReport !== tasks.length) return;
-      settled = true;
-      stopWorkers().then(() => resolve(), reject);
-    };
-
-    const reportReady = () => {
-      try {
-        while (completedResults.has(nextReport)) {
-          const result = completedResults.get(nextReport);
-          completedResults.delete(nextReport);
-          onResult(tasks[nextReport], result);
-          nextReport++;
-        }
-      } catch (error) {
-        fail(error);
-      }
-    };
-
-    const assign = (worker) => {
-      if (nextTask >= tasks.length || settled) return;
-      worker.postMessage({ id: nextTask, name: tasks[nextTask++] });
-    };
-
-    for (const worker of workers) {
-      worker.on('message', ({ id, ms, error }) => {
-        if (settled) return;
-        completedResults.set(id, {
-          ms,
-          error: error == null ? null : Object.assign(new Error(error.message), { stack: error.stack }),
-        });
-        completed++;
-        reportReady();
-        assign(worker);
-        finish();
-      });
-      worker.on('error', fail);
-      assign(worker);
-    }
+// What a worker is asked to do with one example. Results are compared inside
+// the worker, so only a name, an elapsed time, and a failure cross the thread.
+const exampleTaskKinds = {
+  output: runExample,
+  proof: runProofExample,
+};
+
+
+function runExampleTasks(names, kind, reporter) {
+  return runTasksInParallel({
+    names,
+    workerUrl: new URL(import.meta.url),
+    workerData: { exampleWorker: true },
+    message: { kind },
+    maxWorkers: 3,
+    runLocally: (name) => exampleTaskKinds[kind](name),
+    onResult: (name, result) => reporter.testResult(name, result),
   });
 }
 
 function runExampleWorker() {
-  parentPort.on('message', ({ id, name }) => {
-    const startedAt = performance.now();
-    try {
-      runExample(name);
-      parentPort.postMessage({ id, ms: Math.round(performance.now() - startedAt), error: null });
-    } catch (error) {
-      parentPort.postMessage({
-        id,
-        ms: Math.round(performance.now() - startedAt),
-        error: { message: error?.message ?? String(error), stack: error?.stack ?? String(error) },
-      });
-    }
-  });
+  serveTasks(parentPort, ({ kind, name }) => exampleTaskKinds[kind](name));
 }
 
 

package/test/run-proof-checking.mjs

@@ -9,11 +9,13 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { isMainThread, parentPort, workerData } from 'node:worker_threads';
 
 import { Program } from '../src/index.js';
 import { checkProofDocument, checkReportTerms, verdict } from '../src/check-proof.js';
 import { TestReporter, assertEqual, isMainModule, runStandalone } from './test-style.mjs';
 import { proofExamples } from './run-examples.mjs';
+import { runTasksInParallel, serveTasks } from './parallel-tasks.mjs';
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const examplesDir = path.join(root, 'examples');
@@ -43,17 +45,24 @@ const KNOWN_GAPS = new Map([
 // checked here. The list is read from the directory rather than written out,
 // so a proof cannot be added without being checked.
 
-const totals = { steps: 0, verified: 0, redecided: 0, trusted: 0 };
-
-export function runProofChecking(reporter = new TestReporter()) {
+export async function runProofChecking(reporter = new TestReporter()) {
   reporter.section('Proof checking');
-  totals.steps = 0;
-  totals.verified = 0;
-  totals.redecided = 0;
-  totals.trusted = 0;
-  for (const name of [...proofExamples].sort()) {
-    reporter.test(name, () => checkPackagedProof(name));
-  }
+  // Each document is checked on its own against its own program, so the corpus
+  // is checked in parallel and the counts it establishes are summed as the
+  // results come back, in task order, rather than accumulated in a shared
+  // tally a worker could not reach.
+  const totals = { steps: 0, verified: 0, redecided: 0, trusted: 0 };
+  await runTasksInParallel({
+    names: [...proofExamples].sort(),
+    workerUrl: new URL(import.meta.url),
+    workerData: { proofCheckingWorker: true },
+    maxWorkers: 3,
+    runLocally: (name) => checkPackagedProof(name),
+    onResult: (name, result) => {
+      for (const field of Object.keys(totals)) totals[field] += result.value?.[field] ?? 0;
+      reporter.testResult(name, result);
+    },
+  });
   reporter.sectionTotal('proof checking');
   // What the corpus establishes, in the terms the conditions use: a verified
   // step was re-performed against its source clause, a recomputed one was run
@@ -83,19 +92,27 @@ function checkPackagedProof(name) {
   if (expected !== actual) {
     throw new Error(`check report mismatch for ${name}\nexpected:\n${expected}\nactual:\n${actual}`);
   }
-  totals.steps += report.steps;
-  totals.verified += report.verified;
-  totals.redecided += report.redecided;
-  totals.trusted += report.trusted.length;
+  // What this document contributes to the corpus totals, returned rather than
+  // added to a module-level tally so the same function is correct whether it
+  // runs here or in a worker.
+  const contribution = {
+    steps: report.steps,
+    verified: report.verified,
+    redecided: report.redecided,
+    trusted: report.trusted.length,
+  };
   const gap = KNOWN_GAPS.get(name);
   if (gap) {
     assertEqual(report.valid, false, `${name} now checks; remove it from KNOWN_GAPS (${gap})`);
-    return;
+    return contribution;
   }
   const detail = report.failures.slice(0, 3).map((failure) => `[${failure.condition}] ${failure.conclusion} -- ${failure.detail}`).join('; ');
   assertEqual(report.valid, true, `${name}: ${verdict(report)}${detail ? ` -- ${detail}` : ''}`);
+  return contribution;
 }
 
-if (isMainModule(import.meta.url)) {
+if (!isMainThread && workerData?.proofCheckingWorker) {
+  serveTasks(parentPort, ({ name }) => checkPackagedProof(name));
+} else if (isMainModule(import.meta.url)) {
   await runStandalone(runProofChecking);
 }