tla-ts 0.0.3-dev.a50fc89 → 0.0.3-dev.b74f28c

package/src/parallel.ts

@@ -11,7 +11,14 @@ import { parseConfig, type ModelConfig } from "./config";
 import { createEnvironment } from "./environment";
 import { TlaEvaluationError } from "./errors";
 import { isImpure } from "./evaluate";
-import { createFingerprintTable, getFingerprintOwner, writeStateFingerprint } from "./fingerprints";
+import {
+  createSharedFingerprints,
+  growSharedFingerprints,
+  insertSharedFingerprint,
+  isSharedFingerprintsFull,
+  writeStateFingerprint,
+  type SharedFingerprints,
+} from "./fingerprints";
 import { getInitialStates } from "./successors";
 import { getTlcStringOrder, getTlcVariableOrder } from "./tlc-order";
 import { getFingerprintDistance, OUT_DEGREE_BUCKETS } from "./tlc-summary";
@@ -34,10 +41,11 @@ export interface StartMessage {
   modules: [string, string | undefined][];
   classes: [string, Uint8Array | undefined][];
   index: number;
-  count: number;
   ports: (Port | undefined)[];
   seed: EncodedStates;
-  seedFingerprints: Int32Array;
+  fingerprints: SharedFingerprints;
+  requests: Int32Array;
+  remaining: Int32Array;
 }
 
 export interface LevelMessage {
@@ -49,7 +57,15 @@ export interface LevelMessage {
   fingerprints: BigInt64Array;
 }
 
-export type WorkerMessage = { type: "ready" } | { type: "abort" } | LevelMessage;
+export type WorkerMessage =
+  | { type: "ready" }
+  | { type: "abort" }
+  | { type: "paused" }
+  | LevelMessage;
+
+export type CoordinatorMessage =
+  | { type: "level"; level: number }
+  | { type: "resize"; fingerprints: SharedFingerprints };
 
 interface WorkerHandle {
   postMessage: (message: unknown, transfer?: unknown[]) => void;
@@ -90,6 +106,7 @@ export const check = async (options: CheckOptions): Promise<CheckResult> => {
   const count = options.workers ?? 1;
   const isSequential =
     count < 2 ||
+    typeof SharedArrayBuffer !== "function" ||
     config.view !== undefined ||
     config.postconditions.length > 0 ||
     config.possible.length > 0;
@@ -131,12 +148,9 @@ export const check = async (options: CheckOptions): Promise<CheckResult> => {
   }
 
   const canonicalize = createCanonicalizer();
-  const table = createFingerprintTable();
+  const shared = { fingerprints: createSharedFingerprints() };
   const fingerprint = new Int32Array(2);
-  const seeds = Array.from({ length: count }, () => ({
-    encoder: createStateEncoder(),
-    fingerprints: [] as number[],
-  }));
+  const seeds = Array.from({ length: count }, createStateEncoder);
   const statistics = {
     generatedStates: 0,
     distinctStates: 0,
@@ -169,17 +183,15 @@ export const check = async (options: CheckOptions): Promise<CheckResult> => {
       canonicalize(state);
       statistics.generatedStates++;
       writeStateFingerprint(search.getFingerprintState(state), fingerprint);
-      if (!table.insert(fingerprint[0], fingerprint[1])) continue;
+      if (isSharedFingerprintsFull(shared.fingerprints)) {
+        shared.fingerprints = growSharedFingerprints(shared.fingerprints);
+      }
+      if (!insertSharedFingerprint(shared.fingerprints, 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]);
+      if (!search.satisfiesConstraints(state)) continue;
+      if (!seeds[seeded.length % count].encode(state)) return false;
       seeded.push(state);
       statistics.distinctStates++;
     }
@@ -200,18 +212,21 @@ export const check = async (options: CheckOptions): Promise<CheckResult> => {
   if (statistics.distinctStates === 0) return createSuccess();
 
   const reports: WorkerMessage[] = [];
-  const pending = { resolve: (_reports: WorkerMessage[]) => {} };
+  const pending = { count, resolve: (_reports: WorkerMessage[]) => {} };
   const onMessage = (message: WorkerMessage) => {
     reports.push(message);
-    if (message.type === "abort" || reports.length === count) {
+    if (message.type === "abort" || reports.length === pending.count) {
       pending.resolve(reports.splice(0));
     }
   };
-  const waitForReports = () =>
+  const waitForReports = (expected: number) =>
     new Promise<WorkerMessage[]>((resolve) => {
+      pending.count = expected;
       pending.resolve = resolve;
     });
-  const ready = waitForReports();
+  const ready = waitForReports(count);
+  const requests = new Int32Array(new SharedArrayBuffer(count * 4));
+  const remaining = new Int32Array(new SharedArrayBuffer(count * 4));
   const workers = await Promise.all(Array.from({ length: count }, () => spawnWorker(onMessage)));
   const terminate = () => workers.forEach((worker) => worker.terminate());
   const channels = new Map<string, MessageChannel>();
@@ -225,8 +240,7 @@ export const check = async (options: CheckOptions): Promise<CheckResult> => {
     const ports = Array.from({ length: count }, (_, peer) =>
       peer === index ? undefined : getPort(index, peer),
     );
-    const seed = seeds[index].encoder.finish();
-    const seedFingerprints = Int32Array.from(seeds[index].fingerprints);
+    const seed = seeds[index].finish();
     const message: StartMessage = {
       type: "start",
       source: options.source,
@@ -234,27 +248,38 @@ export const check = async (options: CheckOptions): Promise<CheckResult> => {
       modules: [...modules],
       classes: [...classes],
       index,
-      count,
       ports,
       seed,
-      seedFingerprints,
+      fingerprints: shared.fingerprints,
+      requests,
+      remaining,
     };
-    worker.postMessage(message, [
-      ...ports.filter((port) => port !== undefined),
-      seed.words.buffer,
-      seedFingerprints.buffer,
-    ]);
+    worker.postMessage(message, [...ports.filter((port) => port !== undefined), seed.words.buffer]);
   });
   const isAborted = (messages: WorkerMessage[]) =>
     messages.some((message) => message.type === "abort");
+  const send = (message: CoordinatorMessage) =>
+    workers.forEach((worker) => worker.postMessage(message));
+  // Workers pause when the shared table needs to grow, and resume once it has.
+  const collectLevels = async (messages: WorkerMessage[]): Promise<WorkerMessage[]> => {
+    const paused = messages.filter((message) => message.type === "paused").length;
+    if (paused === 0 || isAborted(messages)) return messages;
+    shared.fingerprints = growSharedFingerprints(shared.fingerprints);
+    const resumed = waitForReports(paused);
+    send({ type: "resize", fingerprints: shared.fingerprints });
+    const reported = messages.filter((message) => message.type !== "paused");
+    return [...reported, ...(await collectLevels(await resumed))];
+  };
   if (isAborted(await ready)) {
     terminate();
     return fallBack();
   }
   for (let level = 1; ; level++) {
-    const reported = waitForReports();
-    workers.forEach((worker) => worker.postMessage({ type: "level", level }));
-    const messages = await reported;
+    const reported = waitForReports(count);
+    // Every worker is idle, so peers can ask any of them for states once the level starts.
+    requests.forEach((_, index) => Atomics.store(requests, index, 0));
+    send({ type: "level", level });
+    const messages = await collectLevels(await reported);
     if (isAborted(messages)) {
       terminate();
       return fallBack();

package/src/symmetry.ts

@@ -9,6 +9,7 @@ import {
   isEnumerable,
   isFunctionValue,
   isModelValue,
+  isSameValue,
   isSetValue,
   toFiniteFunction,
   toFiniteSet,
@@ -163,7 +164,10 @@ const permuteValue = (value: Value, permutation: Permutation): Value => {
   if (size === 0 || size > CACHED_SIZE_LIMIT) return computePermutedValue(value, permutation);
   const cached = permutation.cache.get(value);
   if (cached !== undefined) return cached;
-  const permuted = computePermutedValue(value, permutation);
+  const computed = computePermutedValue(value, permutation);
+  // A permutation often maps a value to an equal one. Keeping the original lets the comparison
+  // with the smallest state so far stop at identity.
+  const permuted = computed !== value && isSameValue(computed, value) ? value : computed;
   if (permutation.cacheSize >= permutation.cacheLimit) {
     permutation.cache = new WeakMap();
     permutation.cacheSize = 0;
@@ -184,7 +188,15 @@ const computePermutedValue = (value: ObjectValue, permutation: Permutation) => {
     const domain = permuteElements(functionValue.domain, permutation);
     const range = permuteElements(functionValue.range, permutation) ?? functionValue.range;
     if (domain) {
-      return createFunction(domain.map((key, index): [Value, Value] => [key, range[index]]));
+      const permuted = createFunction(
+        domain.map((key, index): [Value, Value] => [key, range[index]]),
+      );
+      // A permutation often maps the domain to itself, such as a function over the symmetric set.
+      // Sharing the original domain array lets comparisons with other images skip the domain.
+      const isSameDomain = permuted.domain.every(
+        (key, index) => key === functionValue.domain[index],
+      );
+      return isSameDomain ? createSortedFunction(functionValue.domain, permuted.range) : permuted;
     }
     return range === functionValue.range
       ? functionValue

package/src/values.ts

@@ -5,6 +5,7 @@ export interface ModelValue {
   kind: "ModelValue";
   name: string;
   type: string | undefined;
+  rank: number;
 }
 
 export interface SetValue {
@@ -264,6 +265,7 @@ const stringOrder = { ranks: Object.create(null) as Record<string, number>, size
 export const setStringOrder = (texts: Iterable<string>) => {
   stringOrder.ranks = Object.create(null);
   stringOrder.size = 0;
+  modelValues.clear();
   for (const text of texts) rankString(text);
 };
 
@@ -353,7 +355,7 @@ export const compareValues = (left: Value, right: Value): number => {
       if (left.type !== undefined && right.type !== undefined) {
         checkModelValueTypes(left, right, false);
       }
-      return compareStrings(left.name, right.name);
+      return left.rank - right.rank;
     }
     if (leftKind === "ModelValue" || rightKind === "ModelValue") {
       checkModelValueTypes(left, right, false);
@@ -385,14 +387,15 @@ export const compareValues = (left: Value, right: Value): number => {
 
 const modelValues = new Map<string, ModelValue>();
 
+// A check ranks every model value's name when it creates the value, and creates its own values.
 export const createModelValue = (name: string): ModelValue => {
-  rankString(name);
   const known = modelValues.get(name);
   if (known) return known;
   const value: ModelValue = {
     kind: "ModelValue",
     name,
     type: name.length > 2 && name[1] === "_" ? name[0] : undefined,
+    rank: getStringRank(name),
   };
   modelValues.set(name, value);
   return value;
@@ -562,7 +565,7 @@ const equalsModelValueWith = (modelValue: ModelValue, other: Value) => {
 
 const compareModelValue = (left: ModelValue, right: Value) => {
   const type = getModelValueType(left);
-  if (type === undefined) return isModelValue(right) ? compareStrings(left.name, right.name) : -1;
+  if (type === undefined) return isModelValue(right) ? left.rank - right.rank : -1;
   if (!isModelValue(right)) {
     throw new TlaEvaluationError(
       `Attempted to compare the typed model value ${formatValue(left)} and non-model value\n${formatValue(right)}`,
@@ -574,7 +577,7 @@ const compareModelValue = (left: ModelValue, right: Value) => {
       `Attempted to compare the differently-typed model values ${formatValue(left)} and ${formatValue(right)}`,
     );
   }
-  return compareStrings(left.name, right.name);
+  return left.rank - right.rank;
 };
 
 const equalsModelValue = (left: ModelValue, right: Value) => {