tla-ts 0.0.3 → 0.0.4-dev.5f6a4bf
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.
- package/README.md +32 -12
- package/dist/cli.cjs +1 -1
- package/dist/cli.js +1 -1
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +160 -8
- package/dist/index.d.ts +160 -8
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +2 -2
- package/dist/parallel-worker.js +2 -2
- package/dist/parallel.cjs +1 -1
- package/dist/parallel.js +2 -2
- package/dist/run-cli.cjs +45 -18
- package/dist/run-cli.js +45 -18
- package/dist/transfer.cjs +1393 -18
- package/dist/transfer.js +1393 -18
- package/package.json +5 -1
- package/src/ast.ts +147 -6
- package/src/bags.ts +4 -7
- package/src/builtins.ts +29 -11
- package/src/bundled-modules.ts +3 -3
- package/src/canonical.ts +4 -3
- package/src/check.ts +1539 -235
- package/src/cli-options.ts +11 -5
- package/src/cli.ts +8 -1
- package/src/codegen.ts +77 -37
- package/src/config.ts +254 -181
- package/src/dependencies.ts +2 -2
- package/src/environment.ts +540 -140
- package/src/errors.ts +224 -3
- package/src/evaluate.ts +796 -246
- package/src/exit-codes.ts +22 -43
- package/src/fingerprints.ts +46 -11
- package/src/index.ts +1 -0
- package/src/instances.ts +19 -16
- package/src/java-overrides.ts +104 -25
- package/src/levels.ts +191 -45
- package/src/lexer.ts +127 -30
- package/src/live-check.ts +828 -0
- package/src/liveness.ts +218 -572
- package/src/obligation-expression.ts +2 -2
- package/src/obligation-source.ts +2 -0
- package/src/parallel-worker.ts +174 -213
- package/src/parallel.ts +131 -39
- package/src/parser.ts +456 -147
- package/src/pcal-ast.ts +770 -0
- package/src/pcal-parse.ts +1523 -0
- package/src/pcal-tokenize.ts +516 -0
- package/src/pcal-translate.ts +1230 -0
- package/src/pcal-validate.ts +454 -0
- package/src/randomization.ts +24 -7
- package/src/resolve.ts +1481 -426
- package/src/run-cli.ts +1212 -143
- package/src/runtime.ts +19 -1
- package/src/sany-builtins.ts +147 -0
- package/src/sany-generator.ts +3128 -0
- package/src/sany-levels.ts +1208 -0
- package/src/sany-lexer.ts +545 -0
- package/src/sany-linter.ts +122 -0
- package/src/sany-modules.ts +1398 -0
- package/src/sany-nodes.ts +463 -0
- package/src/sany-parse-error.ts +2161 -0
- package/src/sany-report.ts +356 -0
- package/src/sany-selectors.ts +738 -0
- package/src/sany-source.ts +248 -0
- package/src/sany-xml.ts +1017 -0
- package/src/spec-description.ts +42 -11
- package/src/standard-modules.ts +200 -148
- package/src/standard-ranges.ts +116 -0
- package/src/state-graph.ts +180 -0
- package/src/subexpressions.ts +231 -171
- package/src/substitution-levels.ts +38 -17
- package/src/successors.ts +219 -107
- package/src/symmetry.ts +194 -54
- package/src/tableau.ts +54 -25
- package/src/tlc-ext.ts +42 -29
- package/src/tlc-messages.ts +329 -0
- package/src/tlc-module.ts +52 -43
- package/src/tlc-modules.ts +4 -0
- package/src/tlc-order.ts +78 -10
- package/src/tlc-random.ts +37 -9
- package/src/tlc-replay.ts +655 -0
- package/src/tlc-summary.ts +20 -5
- package/src/tlc-version.ts +18 -0
- package/src/transfer.ts +15 -3
- package/src/value-sources.ts +29 -0
- package/src/values.ts +731 -184
|
@@ -874,7 +874,7 @@ export const mapSelectorArgs = (selector: Selector, map: (arg: Expr) => Expr): S
|
|
|
874
874
|
? { ...selector, args: selector.args.map(map) }
|
|
875
875
|
: selector;
|
|
876
876
|
|
|
877
|
-
|
|
877
|
+
const mapExceptSpecs = (specs: ExceptSpec[], map: (inner: Expr) => Expr): ExceptSpec[] =>
|
|
878
878
|
specs.map((spec) => {
|
|
879
879
|
const value = map(spec.value);
|
|
880
880
|
const trail = spec.trail.map((point): ExceptPoint =>
|
|
@@ -883,7 +883,7 @@ export const mapExceptSpecs = (specs: ExceptSpec[], map: (inner: Expr) => Expr):
|
|
|
883
883
|
return { trail, value };
|
|
884
884
|
});
|
|
885
885
|
|
|
886
|
-
|
|
886
|
+
const mapDefnBody = (definition: Defn, map: (body: Expr) => Expr): Defn =>
|
|
887
887
|
definition.kind === "Operator" || definition.kind === "Bpragma"
|
|
888
888
|
? { ...definition, body: map(definition.body) }
|
|
889
889
|
: definition;
|
package/src/obligation-source.ts
CHANGED
|
@@ -609,6 +609,8 @@ export const createSource = (file: string, text: string, counter: Counter, isExp
|
|
|
609
609
|
);
|
|
610
610
|
case "ExceptAt":
|
|
611
611
|
return at({ kind: "At", isExcept }, { location });
|
|
612
|
+
case "Bracket":
|
|
613
|
+
throw new TlaProofError("Unexpected [ without a function or subscript");
|
|
612
614
|
case "FunctionApplication":
|
|
613
615
|
return at(
|
|
614
616
|
{
|
package/src/parallel-worker.ts
CHANGED
|
@@ -1,65 +1,41 @@
|
|
|
1
1
|
import { createCanonicalizer } from "./canonical";
|
|
2
2
|
import { createSearch } from "./check";
|
|
3
3
|
import { createEnvironment } from "./environment";
|
|
4
|
-
import {
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
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, getTlcDeclarationOrder } from "./tlc-order";
|
|
8
19
|
import { OUT_DEGREE_BUCKETS } from "./tlc-summary";
|
|
9
20
|
import { createStateDecoder, createStateEncoder, type EncodedStates } from "./transfer";
|
|
10
|
-
import { getRankedStringCount, setStringOrder, type Value } from "./values";
|
|
21
|
+
import { getRankedStringCount, setStringOrder, setValueVersion, type Value } from "./values";
|
|
11
22
|
|
|
12
23
|
const WORKER_THREADS_MODULE = "node:worker_threads";
|
|
24
|
+
const LOCKED = -1;
|
|
13
25
|
|
|
14
|
-
interface
|
|
26
|
+
interface Expansion {
|
|
15
27
|
states: Value[][];
|
|
16
|
-
|
|
17
|
-
|
|
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[][];
|
|
18
37
|
}
|
|
19
38
|
|
|
20
|
-
interface PeerMessage {
|
|
21
|
-
phase: "query" | "answer" | "sizes" | "balance";
|
|
22
|
-
level: number;
|
|
23
|
-
from: number;
|
|
24
|
-
fingerprints?: Int32Array;
|
|
25
|
-
bits?: Uint8Array;
|
|
26
|
-
states?: EncodedStates;
|
|
27
|
-
unmarks?: Int32Array;
|
|
28
|
-
size?: number;
|
|
29
|
-
}
|
|
30
|
-
|
|
31
|
-
interface Transfer {
|
|
32
|
-
from: number;
|
|
33
|
-
to: number;
|
|
34
|
-
count: number;
|
|
35
|
-
}
|
|
36
|
-
|
|
37
|
-
const getBalancePlan = (sizes: number[]) => {
|
|
38
|
-
const total = sizes.reduce((sum, size) => sum + size, 0);
|
|
39
|
-
const average = total / sizes.length;
|
|
40
|
-
if (Math.max(...sizes) - Math.min(...sizes) <= Math.max(64, average / 4)) return [];
|
|
41
|
-
const targets = sizes.map(
|
|
42
|
-
(_, index) => Math.floor(average) + (index < total % sizes.length ? 1 : 0),
|
|
43
|
-
);
|
|
44
|
-
const donors = sizes.flatMap((size, index) =>
|
|
45
|
-
size > targets[index] ? [{ index, amount: size - targets[index] }] : [],
|
|
46
|
-
);
|
|
47
|
-
const receivers = sizes.flatMap((size, index) =>
|
|
48
|
-
size < targets[index] ? [{ index, amount: targets[index] - size }] : [],
|
|
49
|
-
);
|
|
50
|
-
const transfers: Transfer[] = [];
|
|
51
|
-
for (const donor of donors) {
|
|
52
|
-
for (const receiver of receivers) {
|
|
53
|
-
const moved = Math.min(donor.amount, receiver.amount);
|
|
54
|
-
if (moved === 0) continue;
|
|
55
|
-
transfers.push({ from: donor.index, to: receiver.index, count: moved });
|
|
56
|
-
donor.amount -= moved;
|
|
57
|
-
receiver.amount -= moved;
|
|
58
|
-
}
|
|
59
|
-
}
|
|
60
|
-
return transfers;
|
|
61
|
-
};
|
|
62
|
-
|
|
63
39
|
const getParentPort = async () => {
|
|
64
40
|
if (typeof (globalThis as { postMessage?: unknown }).postMessage === "function") {
|
|
65
41
|
return globalThis as unknown as Port;
|
|
@@ -70,38 +46,12 @@ const getParentPort = async () => {
|
|
|
70
46
|
return threads.parentPort as unknown as Port;
|
|
71
47
|
};
|
|
72
48
|
|
|
73
|
-
const createInbox = () => {
|
|
74
|
-
const messages = new Map<string, PeerMessage[]>();
|
|
75
|
-
const waiters = new Map<string, { count: number; resolve: (messages: PeerMessage[]) => void }>();
|
|
76
|
-
const getKey = (phase: PeerMessage["phase"], level: number) => `${phase}:${level}`;
|
|
77
|
-
const settle = (key: string) => {
|
|
78
|
-
const waiter = waiters.get(key);
|
|
79
|
-
const received = messages.get(key) ?? [];
|
|
80
|
-
if (!waiter || received.length < waiter.count) return;
|
|
81
|
-
waiters.delete(key);
|
|
82
|
-
messages.delete(key);
|
|
83
|
-
waiter.resolve(received);
|
|
84
|
-
};
|
|
85
|
-
return {
|
|
86
|
-
deliver: (message: PeerMessage) => {
|
|
87
|
-
const key = getKey(message.phase, message.level);
|
|
88
|
-
messages.set(key, [...(messages.get(key) ?? []), message]);
|
|
89
|
-
settle(key);
|
|
90
|
-
},
|
|
91
|
-
receive: (phase: PeerMessage["phase"], level: number, count: number) =>
|
|
92
|
-
new Promise<PeerMessage[]>((resolve) => {
|
|
93
|
-
const key = getKey(phase, level);
|
|
94
|
-
waiters.set(key, { count, resolve });
|
|
95
|
-
settle(key);
|
|
96
|
-
}),
|
|
97
|
-
};
|
|
98
|
-
};
|
|
99
|
-
|
|
100
49
|
const run = (start: StartMessage, parent: Port) => {
|
|
101
50
|
const modules = new Map(start.modules);
|
|
102
51
|
const loadModule = (name: string) => modules.get(name);
|
|
103
52
|
const classes = new Map(start.classes);
|
|
104
53
|
setStringOrder(getTlcStringOrder(start.source, start.config, loadModule));
|
|
54
|
+
setValueVersion(start.version);
|
|
105
55
|
const startupStrings = getRankedStringCount();
|
|
106
56
|
const specification = createEnvironment(start.config, {
|
|
107
57
|
source: start.source,
|
|
@@ -109,173 +59,179 @@ const run = (start: StartMessage, parent: Port) => {
|
|
|
109
59
|
loadClass: (name) => classes.get(name),
|
|
110
60
|
print: () => {},
|
|
111
61
|
files: { readFile: undefined, writeFile: undefined },
|
|
62
|
+
isTool: start.isTool,
|
|
63
|
+
isTraceRecorded: start.isTraceRecorded,
|
|
64
|
+
isWarningEnabled: start.isWarningEnabled,
|
|
65
|
+
version: start.version,
|
|
112
66
|
});
|
|
113
67
|
const environment = specification.environment;
|
|
114
68
|
const search = createSearch(start.config, environment, () =>
|
|
115
|
-
|
|
69
|
+
getTlcDeclarationOrder(start.source, loadModule, "variable"),
|
|
116
70
|
);
|
|
117
71
|
const nextAction = search?.spec.next;
|
|
118
72
|
if (!search || nextAction === undefined)
|
|
119
73
|
return parent.postMessage({ type: "abort" } satisfies WorkerMessage);
|
|
120
|
-
const count = start.count;
|
|
121
74
|
const self = start.index;
|
|
122
75
|
const canonicalize = createCanonicalizer();
|
|
123
76
|
const decode = createStateDecoder(environment.variables.length);
|
|
124
|
-
const
|
|
125
|
-
const
|
|
77
|
+
const shared = { fingerprints: start.fingerprints };
|
|
78
|
+
const requests = start.requests;
|
|
79
|
+
const remaining = start.remaining;
|
|
80
|
+
// Under symmetry, a successor the worker generated before has the representative it had then,
|
|
81
|
+
// so the worker skips the search for one.
|
|
82
|
+
const generatedStates = search.isSymmetric ? createFingerprintTable() : undefined;
|
|
126
83
|
const fingerprint = new Int32Array(2);
|
|
127
|
-
const
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
peer.port.start?.();
|
|
84
|
+
const waiters = { resume: () => {}, loot: (_states: EncodedStates) => {} };
|
|
85
|
+
start.ports.forEach((port) => {
|
|
86
|
+
port?.addEventListener("message", (event) => waiters.loot(event.data as EncodedStates));
|
|
87
|
+
port?.start?.();
|
|
132
88
|
});
|
|
133
|
-
for (let index = 0; index < start.seedFingerprints.length; index += 2) {
|
|
134
|
-
table.insert(start.seedFingerprints[index], start.seedFingerprints[index + 1]);
|
|
135
|
-
}
|
|
136
89
|
const frontier = { states: decode(start.seed).map(canonicalize) };
|
|
137
|
-
const send = (index: number, message: PeerMessage, transfer: unknown[]) =>
|
|
138
|
-
start.ports[index]?.postMessage(message, transfer);
|
|
139
90
|
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
const
|
|
147
|
-
const
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
|
|
91
|
+
// A worker that runs out of states asks a peer for some by writing its index + 1 to the peer's
|
|
92
|
+
// request word. The peer sends half of the states it hasn't started, keeps expanding, and wakes
|
|
93
|
+
// the workers waiting to ask it next.
|
|
94
|
+
const answer = (expansion: Expansion, request: number) => {
|
|
95
|
+
const thief = Atomics.load(requests, self) - 1;
|
|
96
|
+
const given = Math.floor((expansion.end - expansion.origin - 1) / 2);
|
|
97
|
+
const encoder = createStateEncoder();
|
|
98
|
+
const states = expansion.states.slice(expansion.end - given, expansion.end);
|
|
99
|
+
const isEncoded = given > 0 && states.every(encoder.encode);
|
|
100
|
+
if (isEncoded) expansion.end -= given;
|
|
101
|
+
const loot = isEncoded ? encoder.finish() : createStateEncoder().finish();
|
|
102
|
+
start.ports[thief]?.postMessage(loot, [loot.words.buffer]);
|
|
103
|
+
Atomics.store(requests, self, request);
|
|
104
|
+
Atomics.notify(requests, self);
|
|
105
|
+
};
|
|
106
|
+
|
|
107
|
+
// A worker answers any request before it pauses or runs out of states, and takes no more until
|
|
108
|
+
// it resumes.
|
|
109
|
+
const lock = (expansion: Expansion) => {
|
|
110
|
+
Atomics.store(remaining, self, 0);
|
|
111
|
+
if (Atomics.compareExchange(requests, self, 0, LOCKED) === 0) return;
|
|
112
|
+
answer(expansion, LOCKED);
|
|
113
|
+
};
|
|
114
|
+
|
|
115
|
+
const unlock = (expansion: Expansion) => {
|
|
116
|
+
Atomics.store(remaining, self, expansion.end - expansion.origin);
|
|
117
|
+
Atomics.store(requests, self, 0);
|
|
118
|
+
};
|
|
119
|
+
|
|
120
|
+
// The worker pauses before a successor when the shared table needs to grow, and resumes there.
|
|
121
|
+
const expand = (expansion: Expansion) => {
|
|
122
|
+
for (; expansion.origin < expansion.end; expansion.origin++) {
|
|
123
|
+
const state = expansion.states[expansion.origin];
|
|
124
|
+
if (!expansion.successors) {
|
|
125
|
+
if (Atomics.load(requests, self) > 0) answer(expansion, 0);
|
|
126
|
+
Atomics.store(remaining, self, expansion.end - expansion.origin - 1);
|
|
127
|
+
expansion.successors = getSuccessors(nextAction, state, environment, search.spec.scope);
|
|
128
|
+
expansion.generated += expansion.successors.length;
|
|
129
|
+
if (expansion.successors.length === 0 && start.config.checkDeadlock) return undefined;
|
|
130
|
+
}
|
|
131
|
+
const successors = expansion.successors;
|
|
132
|
+
for (; expansion.index < successors.length; expansion.index++) {
|
|
133
|
+
if (isSharedFingerprintsFull(shared.fingerprints)) return "paused";
|
|
134
|
+
const successor = successors[expansion.index];
|
|
154
135
|
if (search.findViolatedActionProperty(state, successor.state)) return undefined;
|
|
155
|
-
if (!search.satisfiesActionConstraints(state, successor.state))
|
|
156
|
-
|
|
157
|
-
writeStateFingerprint(search.getFingerprintState(successor.state), fingerprint);
|
|
158
|
-
const owner = getFingerprintOwner(fingerprint[1], count);
|
|
159
|
-
if (owner === self) {
|
|
160
|
-
if (!table.insert(fingerprint[0], fingerprint[1])) continue;
|
|
136
|
+
if (!search.satisfiesActionConstraints(state, successor.state)) {
|
|
137
|
+
// TLC checks the invariants of every successor it has not seen, even outside the model.
|
|
161
138
|
if (search.findViolatedInvariant(successor.state, state)) return undefined;
|
|
162
|
-
if (!search.satisfiesConstraints(successor.state, state)) {
|
|
163
|
-
table.remove(fingerprint[0], fingerprint[1]);
|
|
164
|
-
continue;
|
|
165
|
-
}
|
|
166
|
-
next.push(successor.state);
|
|
167
|
-
newStates[origin]++;
|
|
168
139
|
continue;
|
|
169
140
|
}
|
|
170
|
-
if (
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
141
|
+
if (generatedStates) {
|
|
142
|
+
writeStateFingerprint(successor.state, fingerprint);
|
|
143
|
+
if (!generatedStates.insert(fingerprint[0], fingerprint[1])) continue;
|
|
144
|
+
}
|
|
145
|
+
canonicalize(successor.state);
|
|
146
|
+
const fingerprintState = search.getFingerprintState(successor.state);
|
|
147
|
+
writeStateFingerprint(fingerprintState, fingerprint);
|
|
148
|
+
if (!insertSharedFingerprint(shared.fingerprints, fingerprint[0], fingerprint[1])) continue;
|
|
149
|
+
if (search.findViolatedInvariant(successor.state, state)) return undefined;
|
|
150
|
+
if (!search.satisfiesConstraints(successor.state, state)) continue;
|
|
151
|
+
expansion.next.push(successor.state);
|
|
152
|
+
expansion.fingerprintStates.push(fingerprintState);
|
|
153
|
+
expansion.added++;
|
|
174
154
|
}
|
|
155
|
+
expansion.outDegrees[Math.min(expansion.added, OUT_DEGREE_BUCKETS - 1)]++;
|
|
156
|
+
expansion.successors = undefined;
|
|
157
|
+
expansion.index = 0;
|
|
158
|
+
expansion.added = 0;
|
|
175
159
|
}
|
|
176
|
-
return
|
|
160
|
+
return "done";
|
|
177
161
|
};
|
|
178
162
|
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
const
|
|
193
|
-
if (
|
|
194
|
-
if (
|
|
195
|
-
|
|
196
|
-
|
|
163
|
+
// Each attempt asks the peer with the most states left. While another worker's request to that
|
|
164
|
+
// peer is open, the worker waits for the peer to answer it. The worker stops once no peer that
|
|
165
|
+
// takes requests has two states left.
|
|
166
|
+
const steal = async (expansion: Expansion) => {
|
|
167
|
+
const skipped = new Set<number>();
|
|
168
|
+
for (;;) {
|
|
169
|
+
const victim = start.ports.reduce<number | undefined>((best, port, index) => {
|
|
170
|
+
if (!port || skipped.has(index) || Atomics.load(remaining, index) < 2) return best;
|
|
171
|
+
return best === undefined || Atomics.load(remaining, index) > Atomics.load(remaining, best)
|
|
172
|
+
? index
|
|
173
|
+
: best;
|
|
174
|
+
}, undefined);
|
|
175
|
+
if (victim === undefined) return false;
|
|
176
|
+
const request = Atomics.compareExchange(requests, victim, 0, self + 1);
|
|
177
|
+
if (request === LOCKED) skipped.add(victim);
|
|
178
|
+
if (request > 0) Atomics.wait(requests, victim, request);
|
|
179
|
+
if (request !== 0) continue;
|
|
180
|
+
const loot = await new Promise<EncodedStates>((resolve) => (waiters.loot = resolve));
|
|
181
|
+
if (loot.count === 0) {
|
|
182
|
+
skipped.add(victim);
|
|
197
183
|
continue;
|
|
198
184
|
}
|
|
199
|
-
|
|
200
|
-
|
|
185
|
+
expansion.states = decode(loot).map(canonicalize);
|
|
186
|
+
expansion.origin = 0;
|
|
187
|
+
expansion.end = expansion.states.length;
|
|
188
|
+
unlock(expansion);
|
|
189
|
+
return true;
|
|
201
190
|
}
|
|
202
|
-
return Int32Array.from(unmarks);
|
|
203
191
|
};
|
|
204
192
|
|
|
205
|
-
const
|
|
206
|
-
|
|
207
|
-
table.remove(fingerprints[index], fingerprints[index + 1]);
|
|
208
|
-
}
|
|
209
|
-
};
|
|
210
|
-
|
|
211
|
-
const balance = async (level: number, next: Value[][], sizes: number[]) => {
|
|
212
|
-
const transfers = getBalancePlan(sizes);
|
|
213
|
-
if (transfers.length === 0) return true;
|
|
214
|
-
const outgoing = new Map(peers.map((peer) => [peer.index, createStateEncoder()]));
|
|
215
|
-
for (const transfer of transfers.filter((candidate) => candidate.from === self)) {
|
|
216
|
-
const encoder = outgoing.get(transfer.to);
|
|
217
|
-
const states = next.splice(next.length - transfer.count, transfer.count);
|
|
218
|
-
if (!encoder || !states.every(encoder.encode)) return false;
|
|
219
|
-
}
|
|
220
|
-
outgoing.forEach((encoder, index) => {
|
|
221
|
-
const states = encoder.finish();
|
|
222
|
-
send(index, { phase: "balance", level, from: self, states }, [states.words.buffer]);
|
|
223
|
-
});
|
|
224
|
-
const incoming = await inbox.receive("balance", level, peers.length);
|
|
225
|
-
incoming.forEach((message) => {
|
|
226
|
-
if (message.states) next.push(...decode(message.states).map(canonicalize));
|
|
227
|
-
});
|
|
228
|
-
return true;
|
|
229
|
-
};
|
|
193
|
+
const report = (message: WorkerMessage) =>
|
|
194
|
+
parent.postMessage(message, message.type === "level" ? [message.fingerprints.buffer] : []);
|
|
230
195
|
|
|
231
196
|
const runLevel = async (level: number): Promise<LevelMessage | undefined> => {
|
|
232
|
-
const
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
|
|
243
|
-
}
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
197
|
+
const expansion: Expansion = {
|
|
198
|
+
states: frontier.states,
|
|
199
|
+
origin: 0,
|
|
200
|
+
end: frontier.states.length,
|
|
201
|
+
successors: undefined,
|
|
202
|
+
index: 0,
|
|
203
|
+
added: 0,
|
|
204
|
+
generated: 0,
|
|
205
|
+
outDegrees: Array.from({ length: OUT_DEGREE_BUCKETS }, () => 0),
|
|
206
|
+
next: [],
|
|
207
|
+
fingerprintStates: [],
|
|
208
|
+
};
|
|
209
|
+
for (;;) {
|
|
210
|
+
const status = expand(expansion);
|
|
211
|
+
if (status === undefined) return undefined;
|
|
212
|
+
lock(expansion);
|
|
213
|
+
if (status === "paused") {
|
|
214
|
+
const resumed = new Promise<void>((resolve) => (waiters.resume = resolve));
|
|
215
|
+
report({ type: "paused" });
|
|
216
|
+
await resumed;
|
|
217
|
+
unlock(expansion);
|
|
218
|
+
continue;
|
|
219
|
+
}
|
|
220
|
+
if (!(await steal(expansion))) break;
|
|
254
221
|
}
|
|
255
|
-
const added = next.length;
|
|
256
|
-
const outDegrees = Array.from({ length: OUT_DEGREE_BUCKETS }, () => 0);
|
|
257
|
-
expanded.newStates.forEach((degree) => outDegrees[Math.min(degree, OUT_DEGREE_BUCKETS - 1)]++);
|
|
258
|
-
const fingerprints = BigInt64Array.from(next, (state) =>
|
|
259
|
-
environment.runtime.getFingerprint(state),
|
|
260
|
-
);
|
|
261
|
-
const sizes = Array.from({ length: count }, () => 0);
|
|
262
|
-
sizes[self] = added;
|
|
263
|
-
peers.forEach((peer) =>
|
|
264
|
-
send(peer.index, { phase: "sizes", level, from: self, size: added }, []),
|
|
265
|
-
);
|
|
266
|
-
const received = await inbox.receive("sizes", level, peers.length * 2);
|
|
267
|
-
received.forEach((message) => {
|
|
268
|
-
if (message.unmarks) removeAll(message.unmarks);
|
|
269
|
-
else sizes[message.from] = message.size ?? 0;
|
|
270
|
-
});
|
|
271
222
|
if (getRankedStringCount() !== startupStrings) return undefined;
|
|
272
|
-
|
|
273
|
-
frontier.states
|
|
274
|
-
return {
|
|
223
|
+
frontier.states = expansion.next;
|
|
224
|
+
Atomics.store(remaining, self, frontier.states.length);
|
|
225
|
+
return {
|
|
226
|
+
type: "level",
|
|
227
|
+
level,
|
|
228
|
+
generated: expansion.generated,
|
|
229
|
+
added: expansion.next.length,
|
|
230
|
+
outDegrees: expansion.outDegrees,
|
|
231
|
+
fingerprints: search.getStoredFingerprints(expansion.next, expansion.fingerprintStates),
|
|
232
|
+
};
|
|
275
233
|
};
|
|
276
234
|
|
|
277
|
-
const report = (message: WorkerMessage) =>
|
|
278
|
-
parent.postMessage(message, message.type === "level" ? [message.fingerprints.buffer] : []);
|
|
279
235
|
const step = (level: number) => {
|
|
280
236
|
runLevel(level).then(
|
|
281
237
|
(message) => report(message ?? { type: "abort" }),
|
|
@@ -283,9 +239,14 @@ const run = (start: StartMessage, parent: Port) => {
|
|
|
283
239
|
);
|
|
284
240
|
};
|
|
285
241
|
parent.addEventListener("message", (event) => {
|
|
286
|
-
const message = event.data as
|
|
242
|
+
const message = event.data as CoordinatorMessage;
|
|
287
243
|
if (message.type === "level") step(message.level);
|
|
244
|
+
if (message.type === "resize") {
|
|
245
|
+
shared.fingerprints = message.fingerprints;
|
|
246
|
+
waiters.resume();
|
|
247
|
+
}
|
|
288
248
|
});
|
|
249
|
+
Atomics.store(remaining, self, frontier.states.length);
|
|
289
250
|
report({ type: "ready" });
|
|
290
251
|
};
|
|
291
252
|
|