tla-ts 0.0.1 → 0.0.3-dev.763cc71

package/src/parallel-worker.ts

@@ -1,19 +1,21 @@
 import { createCanonicalizer } from "./canonical";
 import { createSearch } from "./check";
 import { createEnvironment } from "./environment";
-import { createFingerprintTable, getFingerprintOwner, getStateFingerprint } from "./fingerprints";
+import { createFingerprintTable, getFingerprintOwner, writeStateFingerprint } from "./fingerprints";
 import type { LevelMessage, Port, StartMessage, WorkerMessage } from "./parallel";
-import { parseModule } from "./parser";
 import { getSuccessors } from "./successors";
+import { getTlcStringOrder, getTlcVariableOrder } from "./tlc-order";
+import { OUT_DEGREE_BUCKETS } from "./tlc-summary";
 import { createStateDecoder, createStateEncoder, type EncodedStates } from "./transfer";
-import type { Value } from "./values";
+import { getRankedStringCount, setStringOrder, type Value } from "./values";
 
 const WORKER_THREADS_MODULE = "node:worker_threads";
 
 interface Pending {
   states: Value[][];
-  parents: Value[][];
+  origins: number[];
   fingerprints: number[];
+  fingerprintStates: Value[][];
 }
 
 interface PeerMessage {
@@ -33,12 +35,12 @@ interface Transfer {
   count: number;
 }
 
-const getBalancePlan = (sizes: number[]): Transfer[] => {
+const getBalancePlan = (sizes: number[]) => {
   const total = sizes.reduce((sum, size) => sum + size, 0);
   const average = total / sizes.length;
   if (Math.max(...sizes) - Math.min(...sizes) <= Math.max(64, average / 4)) return [];
   const targets = sizes.map(
-    (_, index) => Math.floor(total / sizes.length) + (index < total % sizes.length ? 1 : 0),
+    (_, index) => Math.floor(average) + (index < total % sizes.length ? 1 : 0),
   );
   const donors = sizes.flatMap((size, index) =>
     size > targets[index] ? [{ index, amount: size - targets[index] }] : [],
@@ -59,7 +61,7 @@ const getBalancePlan = (sizes: number[]): Transfer[] => {
   return transfers;
 };
 
-const getParentPort = async (): Promise<Port> => {
+const getParentPort = async () => {
   if (typeof (globalThis as { postMessage?: unknown }).postMessage === "function") {
     return globalThis as unknown as Port;
   }
@@ -98,21 +100,33 @@ const createInbox = () => {
 
 const run = (start: StartMessage, parent: Port) => {
   const modules = new Map(start.modules);
-  const specification = createEnvironment(parseModule(start.source), start.config, {
-    loadModule: (name) => modules.get(name),
+  const loadModule = (name: string) => modules.get(name);
+  const classes = new Map(start.classes);
+  setStringOrder(getTlcStringOrder(start.source, start.config, loadModule));
+  const startupStrings = getRankedStringCount();
+  const specification = createEnvironment(start.config, {
+    source: start.source,
+    loadModule,
+    loadClass: (name) => classes.get(name),
     print: () => {},
     files: { readFile: undefined, writeFile: undefined },
   });
   const environment = specification.environment;
-  const search = createSearch(start.config, environment);
-  if (!search) return parent.postMessage({ type: "abort" } satisfies WorkerMessage);
-  const width = environment.variables.length;
+  const search = createSearch(start.config, environment, () =>
+    getTlcVariableOrder(start.source, loadModule),
+  );
+  const nextAction = search?.spec.next;
+  if (!search || nextAction === undefined)
+    return parent.postMessage({ type: "abort" } satisfies WorkerMessage);
   const count = start.count;
   const self = start.index;
   const canonicalize = createCanonicalizer();
-  const decode = createStateDecoder(width);
+  const decode = createStateDecoder(environment.variables.length);
   const table = createFingerprintTable();
   const known = createFingerprintTable();
+  // Under symmetry, a successor the worker generated before has the representative it had then,
+  // so the worker skips the search for one.
+  const generatedStates = search.isSymmetric ? createFingerprintTable() : undefined;
   const fingerprint = new Int32Array(2);
   const inbox = createInbox();
   const peers = start.ports.flatMap((port, index) => (port ? [{ port, index }] : []));
@@ -127,37 +141,51 @@ const run = (start: StartMessage, parent: Port) => {
   const send = (index: number, message: PeerMessage, transfer: unknown[]) =>
     start.ports[index]?.postMessage(message, transfer);
 
-  const expand = (states: Value[][], next: Value[][]) => {
+  const expand = (states: Value[][], next: Value[][], nextFingerprintStates: Value[][]) => {
     const pending: Pending[] = Array.from({ length: count }, () => ({
       states: [],
-      parents: [],
+      origins: [],
       fingerprints: [],
+      fingerprintStates: [],
     }));
     const statistics = { generated: 0 };
-    for (const state of states) {
-      const successors = getSuccessors(search.spec.next, state, environment);
+    const newStates = new Int32Array(states.length);
+    for (let origin = 0; origin < states.length; origin++) {
+      const state = states[origin];
+      const successors = getSuccessors(nextAction, state, environment, search.spec.scope);
       statistics.generated += successors.length;
       if (successors.length === 0 && start.config.checkDeadlock) return undefined;
       for (const successor of successors) {
         if (search.findViolatedActionProperty(state, successor.state)) return undefined;
         if (!search.satisfiesActionConstraints(state, successor.state)) continue;
+        if (generatedStates) {
+          writeStateFingerprint(successor.state, fingerprint);
+          if (!generatedStates.insert(fingerprint[0], fingerprint[1])) continue;
+        }
         canonicalize(successor.state);
-        getStateFingerprint(search.getFingerprintState(successor.state), fingerprint);
+        const fingerprintState = search.getFingerprintState(successor.state);
+        writeStateFingerprint(fingerprintState, fingerprint);
         const owner = getFingerprintOwner(fingerprint[1], count);
         if (owner === self) {
           if (!table.insert(fingerprint[0], fingerprint[1])) continue;
           if (search.findViolatedInvariant(successor.state, state)) return undefined;
-          if (search.satisfiesConstraints(successor.state, state)) next.push(successor.state);
-          else table.remove(fingerprint[0], fingerprint[1]);
+          if (!search.satisfiesConstraints(successor.state, state)) {
+            table.remove(fingerprint[0], fingerprint[1]);
+            continue;
+          }
+          next.push(successor.state);
+          nextFingerprintStates.push(fingerprintState);
+          newStates[origin]++;
           continue;
         }
         if (!known.insert(fingerprint[0], fingerprint[1])) continue;
         pending[owner].states.push(successor.state);
-        pending[owner].parents.push(state);
+        pending[owner].origins.push(origin);
         pending[owner].fingerprints.push(fingerprint[0], fingerprint[1]);
+        pending[owner].fingerprintStates.push(fingerprintState);
       }
     }
-    return { pending, generated: statistics.generated };
+    return { pending, generated: statistics.generated, newStates };
   };
 
   const answer = (fingerprints: Int32Array | number[]) => {
@@ -168,15 +196,23 @@ const run = (start: StartMessage, parent: Port) => {
     return bits;
   };
 
-  const commit = (pending: Pending, bits: Uint8Array, next: Value[][]) => {
+  const commit = (
+    pending: Pending,
+    bits: Uint8Array,
+    next: Value[][],
+    nextFingerprintStates: Value[][],
+    newStates: Int32Array,
+  ) => {
     const unmarks: number[] = [];
     for (let index = 0; index < bits.length; index++) {
       if (bits[index] === 0) continue;
       const state = pending.states[index];
-      const parentState = pending.parents[index];
+      const parentState = frontier.states[pending.origins[index]];
       if (search.findViolatedInvariant(state, parentState)) return undefined;
       if (search.satisfiesConstraints(state, parentState)) {
         next.push(state);
+        nextFingerprintStates.push(pending.fingerprintStates[index]);
+        newStates[pending.origins[index]]++;
         continue;
       }
       known.remove(pending.fingerprints[index * 2], pending.fingerprints[index * 2 + 1]);
@@ -213,8 +249,9 @@ const run = (start: StartMessage, parent: Port) => {
 
   const runLevel = async (level: number): Promise<LevelMessage | undefined> => {
     const next: Value[][] = [];
-    const expanded = expand(frontier.states, next);
-    if (!expanded) return undefined;
+    const nextFingerprintStates: Value[][] = [];
+    const expanded = expand(frontier.states, next, nextFingerprintStates);
+    if (!expanded || getRankedStringCount() !== startupStrings) return undefined;
     peers.forEach((peer) => {
       const fingerprints = Int32Array.from(expanded.pending[peer.index].fingerprints);
       send(peer.index, { phase: "query", level, from: self, fingerprints }, [fingerprints.buffer]);
@@ -226,11 +263,20 @@ const run = (start: StartMessage, parent: Port) => {
     });
     const answers = await inbox.receive("answer", level, peers.length);
     for (const reply of answers) {
-      const unmarks = commit(expanded.pending[reply.from], reply.bits ?? new Uint8Array(), next);
+      const unmarks = commit(
+        expanded.pending[reply.from],
+        reply.bits ?? new Uint8Array(),
+        next,
+        nextFingerprintStates,
+        expanded.newStates,
+      );
       if (!unmarks) return undefined;
-      send(reply.from, { phase: "sizes", level, from: self, unmarks, size: 0 }, [unmarks.buffer]);
+      send(reply.from, { phase: "sizes", level, from: self, unmarks }, [unmarks.buffer]);
     }
     const added = next.length;
+    const outDegrees = Array.from({ length: OUT_DEGREE_BUCKETS }, () => 0);
+    expanded.newStates.forEach((degree) => outDegrees[Math.min(degree, OUT_DEGREE_BUCKETS - 1)]++);
+    const fingerprints = search.getStoredFingerprints(next, nextFingerprintStates);
     const sizes = Array.from({ length: count }, () => 0);
     sizes[self] = added;
     peers.forEach((peer) =>
@@ -241,12 +287,14 @@ const run = (start: StartMessage, parent: Port) => {
       if (message.unmarks) removeAll(message.unmarks);
       else sizes[message.from] = message.size ?? 0;
     });
+    if (getRankedStringCount() !== startupStrings) return undefined;
     if (!(await balance(level, next, sizes))) return undefined;
     frontier.states = next;
-    return { type: "level", level, generated: expanded.generated, added };
+    return { type: "level", level, generated: expanded.generated, added, outDegrees, fingerprints };
   };
 
-  const report = (message: WorkerMessage) => parent.postMessage(message);
+  const report = (message: WorkerMessage) =>
+    parent.postMessage(message, message.type === "level" ? [message.fingerprints.buffer] : []);
   const step = (level: number) => {
     runLevel(level).then(
       (message) => report(message ?? { type: "abort" }),

package/src/parallel.ts

@@ -1,7 +1,7 @@
 import type { Expression } from "./ast";
 import { createCanonicalizer } from "./canonical";
 import {
-  check,
+  checkSequentially,
   createSearch,
   findAssumptionViolation,
   type CheckOptions,
@@ -9,11 +9,14 @@ import {
 } from "./check";
 import { parseConfig, type ModelConfig } from "./config";
 import { createEnvironment } from "./environment";
-import { getChildren, isImpureBuiltin, type Environment } from "./evaluate";
-import { createFingerprintTable, getFingerprintOwner, getStateFingerprint } from "./fingerprints";
-import { parseModule } from "./parser";
+import { TlaEvaluationError } from "./errors";
+import { isImpure } from "./evaluate";
+import { createFingerprintTable, getFingerprintOwner, writeStateFingerprint } from "./fingerprints";
 import { getInitialStates } from "./successors";
+import { getTlcStringOrder, getTlcVariableOrder } from "./tlc-order";
+import { getFingerprintDistance, OUT_DEGREE_BUCKETS } from "./tlc-summary";
 import { createStateEncoder, type EncodedStates } from "./transfer";
+import { getRankedStringCount, setStringOrder, type Value } from "./values";
 
 const WORKER_THREADS_MODULE = "node:worker_threads";
 
@@ -29,6 +32,7 @@ export interface StartMessage {
   source: string;
   config: ModelConfig;
   modules: [string, string | undefined][];
+  classes: [string, Uint8Array | undefined][];
   index: number;
   count: number;
   ports: (Port | undefined)[];
@@ -41,14 +45,12 @@ export interface LevelMessage {
   level: number;
   generated: number;
   added: number;
+  outDegrees: number[];
+  fingerprints: BigInt64Array;
 }
 
 export type WorkerMessage = { type: "ready" } | { type: "abort" } | LevelMessage;
 
-export interface ParallelCheckOptions extends CheckOptions {
-  workers: number;
-}
-
 interface WorkerHandle {
   postMessage: (message: unknown, transfer?: unknown[]) => void;
   terminate: () => void;
@@ -73,7 +75,7 @@ const spawnWorker = async (onMessage: (message: WorkerMessage) => void): Promise
     /* @vite-ignore */ /* webpackIgnore: true */ WORKER_THREADS_MODULE
   );
   const worker = new threads.Worker(new URL("./parallel-worker.js", import.meta.url));
-  worker.on("message", (message: WorkerMessage) => onMessage(message));
+  worker.on("message", onMessage);
   worker.on("error", () => onMessage({ type: "abort" }));
   return {
     postMessage: (message, transfer) =>
@@ -82,47 +84,52 @@ const spawnWorker = async (onMessage: (message: WorkerMessage) => void): Promise
   };
 };
 
-const usesImpureBuiltin = (expression: Expression, environment: Environment): boolean =>
-  ((expression.kind === "Apply" || expression.kind === "OperatorReference") &&
-    isImpureBuiltin(expression.operator, environment)) ||
-  (expression.kind === "Identifier" && isImpureBuiltin(expression.name, environment)) ||
-  getChildren(expression).some((child) => usesImpureBuiltin(child, environment));
-
-const isImpure = (environment: Environment) =>
-  [...environment.definitions.values()].some(
-    (definition) =>
-      usesImpureBuiltin(definition.body, environment) ||
-      (definition.kind === "Function" &&
-        definition.bounds.some((bound) => usesImpureBuiltin(bound.set, environment))),
-  );
-
-export const checkInParallel = async (options: ParallelCheckOptions): Promise<CheckResult> => {
+export const check = async (options: CheckOptions): Promise<CheckResult> => {
   const config = typeof options.config === "string" ? parseConfig(options.config) : options.config;
-  const checkSequentially = () => check({ ...options, config });
+  const fallBack = () => checkSequentially({ ...options, config });
+  const count = options.workers ?? 1;
   const isSequential =
-    options.workers < 2 ||
+    count < 2 ||
     config.view !== undefined ||
     config.postconditions.length > 0 ||
     config.possible.length > 0;
-  if (isSequential) return checkSequentially();
+  if (isSequential) return fallBack();
   const modules = new Map<string, string | undefined>();
-  const specification = createEnvironment(parseModule(options.source), config, {
-    loadModule: (name) => {
-      const source = options.loadModule?.(name);
-      modules.set(name, source);
-      return source;
-    },
+  const loadModule = (name: string) => {
+    const source = options.loadModule?.(name);
+    modules.set(name, source);
+    return source;
+  };
+  const classes = new Map<string, Uint8Array | undefined>();
+  const loadClass = (name: string) => {
+    const bytes = options.loadClass?.(name);
+    classes.set(name, bytes);
+    return bytes;
+  };
+  setStringOrder(getTlcStringOrder(options.source, config, loadModule));
+  const startupStrings = getRankedStringCount();
+  const specification = createEnvironment(config, {
+    source: options.source,
+    loadModule,
+    loadClass,
     print: options.onPrint ?? console.log,
     files: { readFile: options.readFile, writeFile: options.writeFile },
   });
   const environment = specification.environment;
-  if (findAssumptionViolation(specification.assumptions, environment)) return checkSequentially();
-  const search = createSearch(config, environment);
-  if (!search || search.properties.liveness.length > 0 || isImpure(environment)) {
-    return checkSequentially();
+  const search = createSearch(config, environment, () =>
+    getTlcVariableOrder(options.source, loadModule),
+  );
+  if (findAssumptionViolation(specification.assumptions, environment)) return fallBack();
+  if (
+    !search ||
+    search.spec.init === undefined ||
+    search.spec.next === undefined ||
+    search.properties.liveness.length > 0 ||
+    isImpure(environment)
+  ) {
+    return fallBack();
   }
 
-  const count = options.workers;
   const canonicalize = createCanonicalizer();
   const table = createFingerprintTable();
   const fingerprint = new Int32Array(2);
@@ -130,30 +137,70 @@ export const checkInParallel = async (options: ParallelCheckOptions): Promise<Ch
     encoder: createStateEncoder(),
     fingerprints: [] as number[],
   }));
-  const statistics = { generatedStates: 0, distinctStates: 0, depth: 0 };
-  for (const state of getInitialStates(search.spec.init, environment)) {
-    canonicalize(state);
-    statistics.generatedStates++;
-    getStateFingerprint(search.getFingerprintState(state), fingerprint);
-    if (!table.insert(fingerprint[0], fingerprint[1])) continue;
-    if (search.findViolatedInvariant(state) || search.findFailedInitialPredicate(state)) {
-      return checkSequentially();
-    }
-    if (!search.satisfiesConstraints(state)) {
-      table.remove(fingerprint[0], fingerprint[1]);
-      continue;
+  const statistics = {
+    generatedStates: 0,
+    distinctStates: 0,
+    queuedStates: 0,
+    depth: 0,
+    outDegrees: Array.from({ length: OUT_DEGREE_BUCKETS }, () => 0),
+  };
+  const tlcFingerprints: BigInt64Array[] = [];
+  const createSuccess = (): CheckResult => ({
+    status: "success",
+    violation: undefined,
+    failure: undefined,
+    ...statistics,
+    fingerprintDistance: getFingerprintDistance(
+      statistics.distinctStates,
+      statistics.generatedStates,
+      () => {
+        const fingerprints = new BigInt64Array(statistics.distinctStates);
+        tlcFingerprints.reduce((offset, level) => {
+          fingerprints.set(level, offset);
+          return offset + level.length;
+        }, 0);
+        return fingerprints;
+      },
+    ),
+  });
+  const seedInitialStates = (init: Expression) => {
+    const seeded: Value[][] = [];
+    for (const state of getInitialStates(init, environment, search.spec.scope)) {
+      canonicalize(state);
+      statistics.generatedStates++;
+      writeStateFingerprint(search.getFingerprintState(state), fingerprint);
+      if (!table.insert(fingerprint[0], fingerprint[1])) continue;
+      if (search.findViolatedInvariant(state) || search.findFailedInitialPredicate(state)) {
+        return false;
+      }
+      if (!search.satisfiesConstraints(state)) {
+        table.remove(fingerprint[0], fingerprint[1]);
+        continue;
+      }
+      const seed = seeds[getFingerprintOwner(fingerprint[1], count)];
+      if (!seed.encoder.encode(state)) return false;
+      seed.fingerprints.push(fingerprint[0], fingerprint[1]);
+      seeded.push(state);
+      statistics.distinctStates++;
     }
-    const seed = seeds[getFingerprintOwner(fingerprint[1], count)];
-    if (!seed.encoder.encode(state)) return checkSequentially();
-    seed.fingerprints.push(fingerprint[0], fingerprint[1]);
-    statistics.distinctStates++;
+    tlcFingerprints.push(
+      BigInt64Array.from(seeded, (state) => environment.runtime.getFingerprint(state)),
+    );
+    return true;
+  };
+  // The sequential search reports a violation or a failed evaluation in the initial states.
+  try {
+    if (!seedInitialStates(search.spec.init)) return fallBack();
+  } catch (error) {
+    if (!(error instanceof TlaEvaluationError)) throw error;
+    return fallBack();
   }
-  if (statistics.distinctStates === 0)
-    return { status: "success", violation: undefined, ...statistics };
-  statistics.depth = 1;
+  if (getRankedStringCount() !== startupStrings) return fallBack();
+  statistics.depth = statistics.generatedStates === 0 ? 0 : 1;
+  if (statistics.distinctStates === 0) return createSuccess();
 
   const reports: WorkerMessage[] = [];
-  const pending = { resolve: (_: WorkerMessage[]) => {} };
+  const pending = { resolve: (_reports: WorkerMessage[]) => {} };
   const onMessage = (message: WorkerMessage) => {
     reports.push(message);
     if (message.type === "abort" || reports.length === count) {
@@ -168,7 +215,7 @@ export const checkInParallel = async (options: ParallelCheckOptions): Promise<Ch
   const workers = await Promise.all(Array.from({ length: count }, () => spawnWorker(onMessage)));
   const terminate = () => workers.forEach((worker) => worker.terminate());
   const channels = new Map<string, MessageChannel>();
-  const getPort = (from: number, to: number): Port => {
+  const getPort = (from: number, to: number) => {
     const key = from < to ? `${from}:${to}` : `${to}:${from}`;
     const channel = channels.get(key) ?? new MessageChannel();
     channels.set(key, channel);
@@ -185,6 +232,7 @@ export const checkInParallel = async (options: ParallelCheckOptions): Promise<Ch
       source: options.source,
       config,
       modules: [...modules],
+      classes: [...classes],
       index,
       count,
       ports,
@@ -201,7 +249,7 @@ export const checkInParallel = async (options: ParallelCheckOptions): Promise<Ch
     messages.some((message) => message.type === "abort");
   if (isAborted(await ready)) {
     terminate();
-    return checkSequentially();
+    return fallBack();
   }
   for (let level = 1; ; level++) {
     const reported = waitForReports();
@@ -209,15 +257,21 @@ export const checkInParallel = async (options: ParallelCheckOptions): Promise<Ch
     const messages = await reported;
     if (isAborted(messages)) {
       terminate();
-      return checkSequentially();
+      return fallBack();
     }
     const levels = messages.flatMap((message) => (message.type === "level" ? [message] : []));
     const added = levels.reduce((sum, message) => sum + message.added, 0);
     statistics.generatedStates += levels.reduce((sum, message) => sum + message.generated, 0);
     statistics.distinctStates += added;
+    levels.forEach((message) => {
+      message.outDegrees.forEach(
+        (degreeCount, degree) => (statistics.outDegrees[degree] += degreeCount),
+      );
+      tlcFingerprints.push(message.fingerprints);
+    });
     if (added === 0) {
       terminate();
-      return { status: "success", violation: undefined, ...statistics };
+      return createSuccess();
     }
     statistics.depth++;
   }