tla-ts 0.0.1 → 0.0.3-dev.2032e26

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (71) hide show
  1. package/README.md +95 -40
  2. package/dist/index.cjs +1 -1
  3. package/dist/index.d.cts +216 -30
  4. package/dist/index.d.ts +216 -30
  5. package/dist/index.js +1 -1
  6. package/dist/parallel-worker.cjs +2 -2
  7. package/dist/parallel-worker.js +2 -2
  8. package/dist/parallel.cjs +1 -1
  9. package/dist/parallel.js +2 -2
  10. package/dist/run-cli.cjs +20 -1
  11. package/dist/run-cli.js +20 -1
  12. package/dist/transfer.cjs +392 -39
  13. package/dist/transfer.js +392 -39
  14. package/package.json +6 -2
  15. package/src/ast.ts +122 -5
  16. package/src/bags.ts +161 -71
  17. package/src/builtins.ts +203 -23
  18. package/src/bundled-modules.ts +63 -32
  19. package/src/check.ts +950 -238
  20. package/src/cli-options.ts +58 -0
  21. package/src/codegen.ts +52 -18
  22. package/src/config.ts +39 -11
  23. package/src/environment.ts +485 -140
  24. package/src/errors.ts +64 -1
  25. package/src/evaluate.ts +492 -138
  26. package/src/exit-codes.ts +75 -0
  27. package/src/fingerprints.ts +48 -13
  28. package/src/index.ts +9 -4
  29. package/src/instances.ts +221 -66
  30. package/src/java-overrides.ts +241 -0
  31. package/src/json.ts +153 -72
  32. package/src/levels.ts +850 -0
  33. package/src/lexer.ts +108 -29
  34. package/src/liveness.ts +47 -91
  35. package/src/obligation-action.ts +384 -0
  36. package/src/obligation-anon.ts +575 -0
  37. package/src/obligation-deref.ts +637 -0
  38. package/src/obligation-expression.ts +1060 -0
  39. package/src/obligation-format.ts +406 -0
  40. package/src/obligation-generate.ts +1074 -0
  41. package/src/obligation-levels.ts +329 -0
  42. package/src/obligation-module.ts +1042 -0
  43. package/src/obligation-printer.ts +889 -0
  44. package/src/obligation-proof.ts +76 -0
  45. package/src/obligation-source.ts +1084 -0
  46. package/src/obligation-tuples.ts +184 -0
  47. package/src/obligations.ts +316 -0
  48. package/src/parallel-worker.ts +186 -201
  49. package/src/parallel.ts +176 -84
  50. package/src/parser.ts +970 -206
  51. package/src/pretty-print.ts +259 -0
  52. package/src/randomization.ts +24 -113
  53. package/src/resolve.ts +472 -41
  54. package/src/run-cli.ts +427 -61
  55. package/src/runtime.ts +63 -28
  56. package/src/spec-description.ts +509 -0
  57. package/src/standard-levels.ts +105 -0
  58. package/src/standard-modules.ts +223 -92
  59. package/src/subexpressions.ts +21 -35
  60. package/src/substitution-levels.ts +184 -0
  61. package/src/successors.ts +266 -48
  62. package/src/symmetry.ts +79 -23
  63. package/src/tableau.ts +43 -37
  64. package/src/tlc-ext.ts +120 -33
  65. package/src/tlc-module.ts +71 -47
  66. package/src/tlc-modules.ts +1022 -0
  67. package/src/tlc-order.ts +511 -0
  68. package/src/tlc-random.ts +411 -0
  69. package/src/tlc-summary.ts +109 -0
  70. package/src/transfer.ts +26 -5
  71. package/src/values.ts +1234 -176
@@ -1,65 +1,42 @@
1
1
  import { createCanonicalizer } from "./canonical";
2
2
  import { createSearch } from "./check";
3
3
  import { createEnvironment } from "./environment";
4
- import { createFingerprintTable, getFingerprintOwner, getStateFingerprint } from "./fingerprints";
5
- import type { LevelMessage, Port, StartMessage, WorkerMessage } from "./parallel";
6
- import { parseModule } from "./parser";
7
- import { getSuccessors } from "./successors";
4
+ import {
5
+ createFingerprintTable,
6
+ insertSharedFingerprint,
7
+ isSharedFingerprintsFull,
8
+ writeStateFingerprint,
9
+ } from "./fingerprints";
10
+ import type {
11
+ CoordinatorMessage,
12
+ LevelMessage,
13
+ Port,
14
+ StartMessage,
15
+ WorkerMessage,
16
+ } from "./parallel";
17
+ import { getSuccessors, type Successor } from "./successors";
18
+ import { getTlcStringOrder, getTlcVariableOrder } from "./tlc-order";
19
+ import { OUT_DEGREE_BUCKETS } from "./tlc-summary";
8
20
  import { createStateDecoder, createStateEncoder, type EncodedStates } from "./transfer";
9
- import type { Value } from "./values";
21
+ import { getRankedStringCount, setStringOrder, type Value } from "./values";
10
22
 
11
23
  const WORKER_THREADS_MODULE = "node:worker_threads";
24
+ const LOCKED = -1;
12
25
 
13
- interface Pending {
26
+ interface Expansion {
14
27
  states: Value[][];
15
- parents: Value[][];
16
- fingerprints: number[];
28
+ origin: number;
29
+ end: number;
30
+ successors: Successor[] | undefined;
31
+ index: number;
32
+ added: number;
33
+ generated: number;
34
+ outDegrees: number[];
35
+ next: Value[][];
36
+ fingerprintStates: Value[][];
17
37
  }
18
38
 
19
- interface PeerMessage {
20
- phase: "query" | "answer" | "sizes" | "balance";
21
- level: number;
22
- from: number;
23
- fingerprints?: Int32Array;
24
- bits?: Uint8Array;
25
- states?: EncodedStates;
26
- unmarks?: Int32Array;
27
- size?: number;
28
- }
29
-
30
- interface Transfer {
31
- from: number;
32
- to: number;
33
- count: number;
34
- }
35
-
36
- const getBalancePlan = (sizes: number[]): Transfer[] => {
37
- const total = sizes.reduce((sum, size) => sum + size, 0);
38
- const average = total / sizes.length;
39
- if (Math.max(...sizes) - Math.min(...sizes) <= Math.max(64, average / 4)) return [];
40
- const targets = sizes.map(
41
- (_, index) => Math.floor(total / sizes.length) + (index < total % sizes.length ? 1 : 0),
42
- );
43
- const donors = sizes.flatMap((size, index) =>
44
- size > targets[index] ? [{ index, amount: size - targets[index] }] : [],
45
- );
46
- const receivers = sizes.flatMap((size, index) =>
47
- size < targets[index] ? [{ index, amount: targets[index] - size }] : [],
48
- );
49
- const transfers: Transfer[] = [];
50
- for (const donor of donors) {
51
- for (const receiver of receivers) {
52
- const moved = Math.min(donor.amount, receiver.amount);
53
- if (moved === 0) continue;
54
- transfers.push({ from: donor.index, to: receiver.index, count: moved });
55
- donor.amount -= moved;
56
- receiver.amount -= moved;
57
- }
58
- }
59
- return transfers;
60
- };
61
-
62
- const getParentPort = async (): Promise<Port> => {
39
+ const getParentPort = async () => {
63
40
  if (typeof (globalThis as { postMessage?: unknown }).postMessage === "function") {
64
41
  return globalThis as unknown as Port;
65
42
  }
@@ -69,184 +46,187 @@ const getParentPort = async (): Promise<Port> => {
69
46
  return threads.parentPort as unknown as Port;
70
47
  };
71
48
 
72
- const createInbox = () => {
73
- const messages = new Map<string, PeerMessage[]>();
74
- const waiters = new Map<string, { count: number; resolve: (messages: PeerMessage[]) => void }>();
75
- const getKey = (phase: PeerMessage["phase"], level: number) => `${phase}:${level}`;
76
- const settle = (key: string) => {
77
- const waiter = waiters.get(key);
78
- const received = messages.get(key) ?? [];
79
- if (!waiter || received.length < waiter.count) return;
80
- waiters.delete(key);
81
- messages.delete(key);
82
- waiter.resolve(received);
83
- };
84
- return {
85
- deliver: (message: PeerMessage) => {
86
- const key = getKey(message.phase, message.level);
87
- messages.set(key, [...(messages.get(key) ?? []), message]);
88
- settle(key);
89
- },
90
- receive: (phase: PeerMessage["phase"], level: number, count: number) =>
91
- new Promise<PeerMessage[]>((resolve) => {
92
- const key = getKey(phase, level);
93
- waiters.set(key, { count, resolve });
94
- settle(key);
95
- }),
96
- };
97
- };
98
-
99
49
  const run = (start: StartMessage, parent: Port) => {
100
50
  const modules = new Map(start.modules);
101
- const specification = createEnvironment(parseModule(start.source), start.config, {
102
- loadModule: (name) => modules.get(name),
51
+ const loadModule = (name: string) => modules.get(name);
52
+ const classes = new Map(start.classes);
53
+ setStringOrder(getTlcStringOrder(start.source, start.config, loadModule));
54
+ const startupStrings = getRankedStringCount();
55
+ const specification = createEnvironment(start.config, {
56
+ source: start.source,
57
+ loadModule,
58
+ loadClass: (name) => classes.get(name),
103
59
  print: () => {},
104
60
  files: { readFile: undefined, writeFile: undefined },
105
61
  });
106
62
  const environment = specification.environment;
107
- const search = createSearch(start.config, environment);
108
- if (!search) return parent.postMessage({ type: "abort" } satisfies WorkerMessage);
109
- const width = environment.variables.length;
110
- const count = start.count;
63
+ const search = createSearch(start.config, environment, () =>
64
+ getTlcVariableOrder(start.source, loadModule),
65
+ );
66
+ const nextAction = search?.spec.next;
67
+ if (!search || nextAction === undefined)
68
+ return parent.postMessage({ type: "abort" } satisfies WorkerMessage);
111
69
  const self = start.index;
112
70
  const canonicalize = createCanonicalizer();
113
- const decode = createStateDecoder(width);
114
- const table = createFingerprintTable();
115
- const known = createFingerprintTable();
71
+ const decode = createStateDecoder(environment.variables.length);
72
+ const shared = { fingerprints: start.fingerprints };
73
+ const requests = start.requests;
74
+ const remaining = start.remaining;
75
+ // Under symmetry, a successor the worker generated before has the representative it had then,
76
+ // so the worker skips the search for one.
77
+ const generatedStates = search.isSymmetric ? createFingerprintTable() : undefined;
116
78
  const fingerprint = new Int32Array(2);
117
- const inbox = createInbox();
118
- const peers = start.ports.flatMap((port, index) => (port ? [{ port, index }] : []));
119
- peers.forEach((peer) => {
120
- peer.port.addEventListener("message", (event) => inbox.deliver(event.data as PeerMessage));
121
- peer.port.start?.();
79
+ const waiters = { resume: () => {}, loot: (_states: EncodedStates) => {} };
80
+ start.ports.forEach((port) => {
81
+ port?.addEventListener("message", (event) => waiters.loot(event.data as EncodedStates));
82
+ port?.start?.();
122
83
  });
123
- for (let index = 0; index < start.seedFingerprints.length; index += 2) {
124
- table.insert(start.seedFingerprints[index], start.seedFingerprints[index + 1]);
125
- }
126
84
  const frontier = { states: decode(start.seed).map(canonicalize) };
127
- const send = (index: number, message: PeerMessage, transfer: unknown[]) =>
128
- start.ports[index]?.postMessage(message, transfer);
129
85
 
130
- const expand = (states: Value[][], next: Value[][]) => {
131
- const pending: Pending[] = Array.from({ length: count }, () => ({
132
- states: [],
133
- parents: [],
134
- fingerprints: [],
135
- }));
136
- const statistics = { generated: 0 };
137
- for (const state of states) {
138
- const successors = getSuccessors(search.spec.next, state, environment);
139
- statistics.generated += successors.length;
140
- if (successors.length === 0 && start.config.checkDeadlock) return undefined;
141
- for (const successor of successors) {
86
+ // A worker that runs out of states asks a peer for some by writing its index + 1 to the peer's
87
+ // request word. The peer sends half of the states it hasn't started, keeps expanding, and wakes
88
+ // the workers waiting to ask it next.
89
+ const answer = (expansion: Expansion, request: number) => {
90
+ const thief = Atomics.load(requests, self) - 1;
91
+ const given = Math.floor((expansion.end - expansion.origin - 1) / 2);
92
+ const encoder = createStateEncoder();
93
+ const states = expansion.states.slice(expansion.end - given, expansion.end);
94
+ const isEncoded = given > 0 && states.every(encoder.encode);
95
+ if (isEncoded) expansion.end -= given;
96
+ const loot = isEncoded ? encoder.finish() : createStateEncoder().finish();
97
+ start.ports[thief]?.postMessage(loot, [loot.words.buffer]);
98
+ Atomics.store(requests, self, request);
99
+ Atomics.notify(requests, self);
100
+ };
101
+
102
+ // A worker answers any request before it pauses or runs out of states, and takes no more until
103
+ // it resumes.
104
+ const lock = (expansion: Expansion) => {
105
+ Atomics.store(remaining, self, 0);
106
+ if (Atomics.compareExchange(requests, self, 0, LOCKED) === 0) return;
107
+ answer(expansion, LOCKED);
108
+ };
109
+
110
+ const unlock = (expansion: Expansion) => {
111
+ Atomics.store(remaining, self, expansion.end - expansion.origin);
112
+ Atomics.store(requests, self, 0);
113
+ };
114
+
115
+ // The worker pauses before a successor when the shared table needs to grow, and resumes there.
116
+ const expand = (expansion: Expansion) => {
117
+ for (; expansion.origin < expansion.end; expansion.origin++) {
118
+ const state = expansion.states[expansion.origin];
119
+ if (!expansion.successors) {
120
+ if (Atomics.load(requests, self) > 0) answer(expansion, 0);
121
+ Atomics.store(remaining, self, expansion.end - expansion.origin - 1);
122
+ expansion.successors = getSuccessors(nextAction, state, environment, search.spec.scope);
123
+ expansion.generated += expansion.successors.length;
124
+ if (expansion.successors.length === 0 && start.config.checkDeadlock) return undefined;
125
+ }
126
+ const successors = expansion.successors;
127
+ for (; expansion.index < successors.length; expansion.index++) {
128
+ if (isSharedFingerprintsFull(shared.fingerprints)) return "paused";
129
+ const successor = successors[expansion.index];
142
130
  if (search.findViolatedActionProperty(state, successor.state)) return undefined;
143
- if (!search.satisfiesActionConstraints(state, successor.state)) continue;
144
- canonicalize(successor.state);
145
- getStateFingerprint(search.getFingerprintState(successor.state), fingerprint);
146
- const owner = getFingerprintOwner(fingerprint[1], count);
147
- if (owner === self) {
148
- if (!table.insert(fingerprint[0], fingerprint[1])) continue;
131
+ if (!search.satisfiesActionConstraints(state, successor.state)) {
132
+ // TLC checks the invariants of every successor it has not seen, even outside the model.
149
133
  if (search.findViolatedInvariant(successor.state, state)) return undefined;
150
- if (search.satisfiesConstraints(successor.state, state)) next.push(successor.state);
151
- else table.remove(fingerprint[0], fingerprint[1]);
152
134
  continue;
153
135
  }
154
- if (!known.insert(fingerprint[0], fingerprint[1])) continue;
155
- pending[owner].states.push(successor.state);
156
- pending[owner].parents.push(state);
157
- pending[owner].fingerprints.push(fingerprint[0], fingerprint[1]);
136
+ if (generatedStates) {
137
+ writeStateFingerprint(successor.state, fingerprint);
138
+ if (!generatedStates.insert(fingerprint[0], fingerprint[1])) continue;
139
+ }
140
+ canonicalize(successor.state);
141
+ const fingerprintState = search.getFingerprintState(successor.state);
142
+ writeStateFingerprint(fingerprintState, fingerprint);
143
+ if (!insertSharedFingerprint(shared.fingerprints, fingerprint[0], fingerprint[1])) continue;
144
+ if (search.findViolatedInvariant(successor.state, state)) return undefined;
145
+ if (!search.satisfiesConstraints(successor.state, state)) continue;
146
+ expansion.next.push(successor.state);
147
+ expansion.fingerprintStates.push(fingerprintState);
148
+ expansion.added++;
158
149
  }
150
+ expansion.outDegrees[Math.min(expansion.added, OUT_DEGREE_BUCKETS - 1)]++;
151
+ expansion.successors = undefined;
152
+ expansion.index = 0;
153
+ expansion.added = 0;
159
154
  }
160
- return { pending, generated: statistics.generated };
161
- };
162
-
163
- const answer = (fingerprints: Int32Array | number[]) => {
164
- const bits = new Uint8Array(fingerprints.length / 2);
165
- for (let index = 0; index < bits.length; index++) {
166
- bits[index] = table.insert(fingerprints[index * 2], fingerprints[index * 2 + 1]) ? 1 : 0;
167
- }
168
- return bits;
155
+ return "done";
169
156
  };
170
157
 
171
- const commit = (pending: Pending, bits: Uint8Array, next: Value[][]) => {
172
- const unmarks: number[] = [];
173
- for (let index = 0; index < bits.length; index++) {
174
- if (bits[index] === 0) continue;
175
- const state = pending.states[index];
176
- const parentState = pending.parents[index];
177
- if (search.findViolatedInvariant(state, parentState)) return undefined;
178
- if (search.satisfiesConstraints(state, parentState)) {
179
- next.push(state);
158
+ // Each attempt asks the peer with the most states left. While another worker's request to that
159
+ // peer is open, the worker waits for the peer to answer it. The worker stops once no peer that
160
+ // takes requests has two states left.
161
+ const steal = async (expansion: Expansion) => {
162
+ const skipped = new Set<number>();
163
+ for (;;) {
164
+ const victim = start.ports.reduce<number | undefined>((best, port, index) => {
165
+ if (!port || skipped.has(index) || Atomics.load(remaining, index) < 2) return best;
166
+ return best === undefined || Atomics.load(remaining, index) > Atomics.load(remaining, best)
167
+ ? index
168
+ : best;
169
+ }, undefined);
170
+ if (victim === undefined) return false;
171
+ const request = Atomics.compareExchange(requests, victim, 0, self + 1);
172
+ if (request === LOCKED) skipped.add(victim);
173
+ if (request > 0) Atomics.wait(requests, victim, request);
174
+ if (request !== 0) continue;
175
+ const loot = await new Promise<EncodedStates>((resolve) => (waiters.loot = resolve));
176
+ if (loot.count === 0) {
177
+ skipped.add(victim);
180
178
  continue;
181
179
  }
182
- known.remove(pending.fingerprints[index * 2], pending.fingerprints[index * 2 + 1]);
183
- unmarks.push(pending.fingerprints[index * 2], pending.fingerprints[index * 2 + 1]);
180
+ expansion.states = decode(loot).map(canonicalize);
181
+ expansion.origin = 0;
182
+ expansion.end = expansion.states.length;
183
+ unlock(expansion);
184
+ return true;
184
185
  }
185
- return Int32Array.from(unmarks);
186
186
  };
187
187
 
188
- const removeAll = (fingerprints: Int32Array) => {
189
- for (let index = 0; index < fingerprints.length; index += 2) {
190
- table.remove(fingerprints[index], fingerprints[index + 1]);
191
- }
192
- };
193
-
194
- const balance = async (level: number, next: Value[][], sizes: number[]) => {
195
- const transfers = getBalancePlan(sizes);
196
- if (transfers.length === 0) return true;
197
- const outgoing = new Map(peers.map((peer) => [peer.index, createStateEncoder()]));
198
- for (const transfer of transfers.filter((candidate) => candidate.from === self)) {
199
- const encoder = outgoing.get(transfer.to);
200
- const states = next.splice(next.length - transfer.count, transfer.count);
201
- if (!encoder || !states.every(encoder.encode)) return false;
202
- }
203
- outgoing.forEach((encoder, index) => {
204
- const states = encoder.finish();
205
- send(index, { phase: "balance", level, from: self, states }, [states.words.buffer]);
206
- });
207
- const incoming = await inbox.receive("balance", level, peers.length);
208
- incoming.forEach((message) => {
209
- if (message.states) next.push(...decode(message.states).map(canonicalize));
210
- });
211
- return true;
212
- };
188
+ const report = (message: WorkerMessage) =>
189
+ parent.postMessage(message, message.type === "level" ? [message.fingerprints.buffer] : []);
213
190
 
214
191
  const runLevel = async (level: number): Promise<LevelMessage | undefined> => {
215
- const next: Value[][] = [];
216
- const expanded = expand(frontier.states, next);
217
- if (!expanded) return undefined;
218
- peers.forEach((peer) => {
219
- const fingerprints = Int32Array.from(expanded.pending[peer.index].fingerprints);
220
- send(peer.index, { phase: "query", level, from: self, fingerprints }, [fingerprints.buffer]);
221
- });
222
- const queries = await inbox.receive("query", level, peers.length);
223
- queries.forEach((query) => {
224
- const bits = answer(query.fingerprints ?? []);
225
- send(query.from, { phase: "answer", level, from: self, bits }, [bits.buffer]);
226
- });
227
- const answers = await inbox.receive("answer", level, peers.length);
228
- for (const reply of answers) {
229
- const unmarks = commit(expanded.pending[reply.from], reply.bits ?? new Uint8Array(), next);
230
- if (!unmarks) return undefined;
231
- send(reply.from, { phase: "sizes", level, from: self, unmarks, size: 0 }, [unmarks.buffer]);
192
+ const expansion: Expansion = {
193
+ states: frontier.states,
194
+ origin: 0,
195
+ end: frontier.states.length,
196
+ successors: undefined,
197
+ index: 0,
198
+ added: 0,
199
+ generated: 0,
200
+ outDegrees: Array.from({ length: OUT_DEGREE_BUCKETS }, () => 0),
201
+ next: [],
202
+ fingerprintStates: [],
203
+ };
204
+ for (;;) {
205
+ const status = expand(expansion);
206
+ if (status === undefined) return undefined;
207
+ lock(expansion);
208
+ if (status === "paused") {
209
+ const resumed = new Promise<void>((resolve) => (waiters.resume = resolve));
210
+ report({ type: "paused" });
211
+ await resumed;
212
+ unlock(expansion);
213
+ continue;
214
+ }
215
+ if (!(await steal(expansion))) break;
232
216
  }
233
- const added = next.length;
234
- const sizes = Array.from({ length: count }, () => 0);
235
- sizes[self] = added;
236
- peers.forEach((peer) =>
237
- send(peer.index, { phase: "sizes", level, from: self, size: added }, []),
238
- );
239
- const received = await inbox.receive("sizes", level, peers.length * 2);
240
- received.forEach((message) => {
241
- if (message.unmarks) removeAll(message.unmarks);
242
- else sizes[message.from] = message.size ?? 0;
243
- });
244
- if (!(await balance(level, next, sizes))) return undefined;
245
- frontier.states = next;
246
- return { type: "level", level, generated: expanded.generated, added };
217
+ if (getRankedStringCount() !== startupStrings) return undefined;
218
+ frontier.states = expansion.next;
219
+ Atomics.store(remaining, self, frontier.states.length);
220
+ return {
221
+ type: "level",
222
+ level,
223
+ generated: expansion.generated,
224
+ added: expansion.next.length,
225
+ outDegrees: expansion.outDegrees,
226
+ fingerprints: search.getStoredFingerprints(expansion.next, expansion.fingerprintStates),
227
+ };
247
228
  };
248
229
 
249
- const report = (message: WorkerMessage) => parent.postMessage(message);
250
230
  const step = (level: number) => {
251
231
  runLevel(level).then(
252
232
  (message) => report(message ?? { type: "abort" }),
@@ -254,9 +234,14 @@ const run = (start: StartMessage, parent: Port) => {
254
234
  );
255
235
  };
256
236
  parent.addEventListener("message", (event) => {
257
- const message = event.data as { type: string; level: number };
237
+ const message = event.data as CoordinatorMessage;
258
238
  if (message.type === "level") step(message.level);
239
+ if (message.type === "resize") {
240
+ shared.fingerprints = message.fingerprints;
241
+ waiters.resume();
242
+ }
259
243
  });
244
+ Atomics.store(remaining, self, frontier.states.length);
260
245
  report({ type: "ready" });
261
246
  };
262
247