tla-ts 0.0.2 → 0.0.3-dev.037ac3b
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 +78 -12
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +60 -1
- package/dist/index.d.ts +60 -1
- 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 +21 -2
- package/dist/run-cli.js +21 -2
- package/dist/transfer.cjs +27 -15
- package/dist/transfer.js +27 -15
- package/package.json +3 -1
- package/src/ast.ts +134 -4
- package/src/check.ts +280 -80
- package/src/cli-options.ts +64 -0
- package/src/codegen.ts +9 -19
- package/src/dependencies.ts +2 -2
- package/src/environment.ts +75 -16
- package/src/errors.ts +46 -3
- package/src/evaluate.ts +88 -143
- package/src/exit-codes.ts +21 -43
- package/src/fingerprints.ts +46 -11
- package/src/instances.ts +15 -14
- package/src/levels.ts +8 -8
- package/src/lexer.ts +11 -2
- package/src/live-check.ts +692 -0
- package/src/liveness.ts +54 -535
- package/src/obligation-action.ts +384 -0
- package/src/obligation-anon.ts +575 -0
- package/src/obligation-deref.ts +637 -0
- package/src/obligation-expression.ts +1060 -0
- package/src/obligation-format.ts +406 -0
- package/src/obligation-generate.ts +1074 -0
- package/src/obligation-levels.ts +329 -0
- package/src/obligation-module.ts +1042 -0
- package/src/obligation-printer.ts +889 -0
- package/src/obligation-proof.ts +76 -0
- package/src/obligation-source.ts +1084 -0
- package/src/obligation-tuples.ts +184 -0
- package/src/obligations.ts +316 -0
- package/src/parallel-worker.ts +166 -210
- package/src/parallel.ts +76 -35
- package/src/parser.ts +297 -53
- package/src/resolve.ts +16 -15
- package/src/run-cli.ts +353 -40
- package/src/runtime.ts +3 -1
- package/src/spec-description.ts +18 -6
- package/src/standard-levels.ts +3 -3
- package/src/standard-modules.ts +2 -7
- package/src/state-graph.ts +157 -0
- package/src/subexpressions.ts +10 -10
- package/src/successors.ts +77 -13
- package/src/symmetry.ts +14 -2
- package/src/tableau.ts +50 -23
- package/src/tlc-ext.ts +29 -12
- package/src/tlc-module.ts +9 -28
- package/src/tlc-order.ts +17 -3
- package/src/tlc-random.ts +9 -6
- package/src/tlc-summary.ts +20 -5
- package/src/transfer.ts +22 -1
- package/src/values.ts +118 -34
package/src/check.ts
CHANGED
|
@@ -1,15 +1,27 @@
|
|
|
1
|
-
import
|
|
1
|
+
import {
|
|
2
|
+
getChildren,
|
|
3
|
+
isLocallyResolved,
|
|
4
|
+
type Assumption,
|
|
5
|
+
type Definition,
|
|
6
|
+
type Expression,
|
|
7
|
+
type SourceLocation,
|
|
8
|
+
} from "./ast";
|
|
2
9
|
import { parseConfig, type ConfigValue, type ModelConfig } from "./config";
|
|
3
10
|
import { getReadVariables } from "./dependencies";
|
|
4
11
|
import { createEnvironment } from "./environment";
|
|
5
|
-
import {
|
|
6
|
-
|
|
12
|
+
import {
|
|
13
|
+
getErrorExitCode,
|
|
14
|
+
TlaConfigError,
|
|
15
|
+
TlaEvaluationError,
|
|
16
|
+
TlaModuleError,
|
|
17
|
+
UNEXPECTED_EXCEPTION,
|
|
18
|
+
} from "./errors";
|
|
19
|
+
import { EXIT_STATUS, setExitCode, withLivenessExitCode } from "./exit-codes";
|
|
7
20
|
import {
|
|
8
21
|
describeRange,
|
|
9
22
|
evaluate,
|
|
10
23
|
expectBoolean,
|
|
11
24
|
formatRange,
|
|
12
|
-
getChildren,
|
|
13
25
|
getDefinition,
|
|
14
26
|
isConstantLevel,
|
|
15
27
|
isImpure,
|
|
@@ -19,13 +31,11 @@ import {
|
|
|
19
31
|
} from "./evaluate";
|
|
20
32
|
import {
|
|
21
33
|
createLivenessChecker,
|
|
22
|
-
expandTemporal,
|
|
23
|
-
getLevel,
|
|
24
34
|
type Lasso,
|
|
35
|
+
type LivenessChecker,
|
|
25
36
|
type LiveSuccessor,
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
} from "./liveness";
|
|
37
|
+
} from "./live-check";
|
|
38
|
+
import { expandTemporal, getLevel, type ScopedExpression, type TemporalProperty } from "./liveness";
|
|
29
39
|
import { ACTION_LEVEL, createLevelAnalyzer, TEMPORAL_LEVEL } from "./levels";
|
|
30
40
|
import { prettyPrint } from "./pretty-print";
|
|
31
41
|
import {
|
|
@@ -37,10 +47,17 @@ import {
|
|
|
37
47
|
} from "./successors";
|
|
38
48
|
import {
|
|
39
49
|
getActionLabel,
|
|
50
|
+
getActionSignature,
|
|
40
51
|
getNextActions,
|
|
41
52
|
getSpecificationValue,
|
|
42
53
|
type SpecAction,
|
|
43
54
|
} from "./spec-description";
|
|
55
|
+
import {
|
|
56
|
+
createStateWriter,
|
|
57
|
+
type GraphState,
|
|
58
|
+
type StateDump,
|
|
59
|
+
type StateWriter,
|
|
60
|
+
} from "./state-graph";
|
|
44
61
|
import { getRepresentative, getSymmetryGroup } from "./symmetry";
|
|
45
62
|
import { getTlcStringOrder, getTlcVariableOrder } from "./tlc-order";
|
|
46
63
|
import { createTlcFingerprinter, getTlcFingerprint } from "./tlc-random";
|
|
@@ -50,10 +67,12 @@ import { createCounterExample } from "./tlc-ext";
|
|
|
50
67
|
import { getFingerprintDistance, OUT_DEGREE_BUCKETS } from "./tlc-summary";
|
|
51
68
|
import {
|
|
52
69
|
combineHash,
|
|
70
|
+
formatState,
|
|
53
71
|
formatValue,
|
|
54
72
|
getValueHash,
|
|
55
73
|
isFunctionValue,
|
|
56
74
|
isSameValue,
|
|
75
|
+
isUpdatedElementOf,
|
|
57
76
|
setStringOrder,
|
|
58
77
|
toFiniteFunction,
|
|
59
78
|
type Value,
|
|
@@ -72,6 +91,8 @@ export interface CheckOptions {
|
|
|
72
91
|
workers?: number;
|
|
73
92
|
// TLC's -lncheck: "final" checks liveness only on the complete state graph.
|
|
74
93
|
livenessCheck?: "default" | "final";
|
|
94
|
+
// TLC's -dump: writes the reachable states, or with `dot` the state graph, through writeFile.
|
|
95
|
+
dump?: StateDump;
|
|
75
96
|
}
|
|
76
97
|
|
|
77
98
|
export type CheckStatus =
|
|
@@ -93,6 +114,8 @@ export interface TraceStep {
|
|
|
93
114
|
|
|
94
115
|
export interface Violation {
|
|
95
116
|
name: string;
|
|
117
|
+
// Every temporal property that a liveness counterexample violates, in the configuration's order.
|
|
118
|
+
properties?: string[];
|
|
96
119
|
trace: TraceStep[];
|
|
97
120
|
loopStart: number | undefined;
|
|
98
121
|
loopLabel?: string;
|
|
@@ -139,6 +162,13 @@ interface NamedExpression {
|
|
|
139
162
|
|
|
140
163
|
interface StateCheck extends NamedExpression {
|
|
141
164
|
variables: number[] | undefined;
|
|
165
|
+
membership: Membership | undefined;
|
|
166
|
+
}
|
|
167
|
+
|
|
168
|
+
// A conjunct `x \in S` whose S reads no variables.
|
|
169
|
+
interface Membership {
|
|
170
|
+
variable: number;
|
|
171
|
+
set: Expression;
|
|
142
172
|
}
|
|
143
173
|
|
|
144
174
|
interface ActionProperty {
|
|
@@ -416,12 +446,12 @@ const getProperties = (config: ModelConfig, environment: Environment): Propertie
|
|
|
416
446
|
config.properties.forEach((name) => {
|
|
417
447
|
const definition = getConfigPredicate("property", name, environment);
|
|
418
448
|
if (!definition) return;
|
|
419
|
-
expandTemporal(definition.body, undefined, environment, true).forEach((item) => {
|
|
449
|
+
expandTemporal(definition.body, undefined, environment, true, name).forEach((item) => {
|
|
420
450
|
const conjunct = item.expression;
|
|
421
451
|
if (isConstantTrue(item, environment, "property")) return;
|
|
422
452
|
if (conjunct.kind === "Always" && conjunct.expression.kind === "BoxAction") {
|
|
423
453
|
properties.actionProperties.push({
|
|
424
|
-
name,
|
|
454
|
+
name: item.name,
|
|
425
455
|
box: conjunct.expression,
|
|
426
456
|
action: conjunct.expression.action,
|
|
427
457
|
subscript: conjunct.expression.subscript,
|
|
@@ -433,12 +463,22 @@ const getProperties = (config: ModelConfig, environment: Environment): Propertie
|
|
|
433
463
|
conjunct.kind === "Always" &&
|
|
434
464
|
getLevel(conjunct.expression, item.scope, environment) <= 1
|
|
435
465
|
) {
|
|
436
|
-
|
|
466
|
+
// TLC names the invariant []P after P when P is an operator name.
|
|
467
|
+
const expression = conjunct.expression;
|
|
468
|
+
properties.invariants.push({
|
|
469
|
+
name: expression.kind === "Identifier" ? expression.name : item.name,
|
|
470
|
+
expression,
|
|
471
|
+
scope: item.scope,
|
|
472
|
+
});
|
|
437
473
|
return;
|
|
438
474
|
}
|
|
439
475
|
const level = getLevel(conjunct, item.scope, environment);
|
|
440
476
|
if (level < ACTION_LEVEL) {
|
|
441
|
-
properties.initialPredicates.push({
|
|
477
|
+
properties.initialPredicates.push({
|
|
478
|
+
name: item.name,
|
|
479
|
+
expression: conjunct,
|
|
480
|
+
scope: item.scope,
|
|
481
|
+
});
|
|
442
482
|
return;
|
|
443
483
|
}
|
|
444
484
|
if (level === ACTION_LEVEL) {
|
|
@@ -481,14 +521,34 @@ const getPossiblePredicates = (names: string[], environment: Environment) =>
|
|
|
481
521
|
return { name, expression, scope: undefined };
|
|
482
522
|
});
|
|
483
523
|
|
|
524
|
+
const getMembership = (
|
|
525
|
+
expression: Expression,
|
|
526
|
+
variables: number[] | undefined,
|
|
527
|
+
environment: Environment,
|
|
528
|
+
): Membership | undefined => {
|
|
529
|
+
if (expression.kind !== "Apply" || expression.operator !== "\\in" || variables?.length !== 1)
|
|
530
|
+
return undefined;
|
|
531
|
+
const element = expression.args[0];
|
|
532
|
+
if (element.kind !== "Identifier" || isLocallyResolved(element)) return undefined;
|
|
533
|
+
return environment.variableIndex.get(element.name) === variables[0]
|
|
534
|
+
? { variable: variables[0], set: expression.args[1] }
|
|
535
|
+
: undefined;
|
|
536
|
+
};
|
|
537
|
+
|
|
484
538
|
const getStateChecks = (named: NamedExpression[], environment: Environment): StateCheck[] =>
|
|
485
539
|
named.flatMap((item) =>
|
|
486
|
-
getConjuncts(item.expression, environment).map((expression) =>
|
|
487
|
-
name
|
|
488
|
-
|
|
489
|
-
|
|
490
|
-
|
|
491
|
-
|
|
540
|
+
getConjuncts(item.expression, environment).map((expression) => {
|
|
541
|
+
// A LET or an argument in the scope can read variables the expression doesn't name.
|
|
542
|
+
const variables =
|
|
543
|
+
item.scope === undefined ? getReadVariables(expression, environment) : undefined;
|
|
544
|
+
return {
|
|
545
|
+
name: item.name,
|
|
546
|
+
expression,
|
|
547
|
+
scope: item.scope,
|
|
548
|
+
variables,
|
|
549
|
+
membership: getMembership(expression, variables, environment),
|
|
550
|
+
};
|
|
551
|
+
}),
|
|
492
552
|
);
|
|
493
553
|
|
|
494
554
|
const isUnchangedFor = (stateCheck: StateCheck, state: Value[], parent: Value[] | undefined) => {
|
|
@@ -727,11 +787,13 @@ export const createSearch = (
|
|
|
727
787
|
if (view !== undefined || isFingerprintedLikeTlc) {
|
|
728
788
|
return BigInt64Array.from(states, getTlcStateFingerprint);
|
|
729
789
|
}
|
|
730
|
-
const
|
|
731
|
-
const
|
|
732
|
-
|
|
733
|
-
|
|
790
|
+
const fingerprints = new BigInt64Array(fingerprintStates.length);
|
|
791
|
+
const fingerprint = createTlcFingerprinter(
|
|
792
|
+
getTlcOrder(),
|
|
793
|
+
new Int32Array(fingerprints.buffer),
|
|
734
794
|
);
|
|
795
|
+
fingerprintStates.forEach(fingerprint);
|
|
796
|
+
return fingerprints;
|
|
735
797
|
},
|
|
736
798
|
getFingerprintState: (state) => {
|
|
737
799
|
if (isFingerprintedLikeTlc) return [String(getTlcStateFingerprint(state))];
|
|
@@ -743,10 +805,16 @@ export const createSearch = (
|
|
|
743
805
|
invariants.find((invariant) => {
|
|
744
806
|
if (isUnchangedFor(invariant, state, parent)) return false;
|
|
745
807
|
try {
|
|
746
|
-
|
|
747
|
-
|
|
748
|
-
|
|
749
|
-
|
|
808
|
+
const context = getContext(environment, state, undefined, invariant.scope);
|
|
809
|
+
const membership = invariant.membership;
|
|
810
|
+
// The parent satisfies every invariant, so only the entries the step changed can fail.
|
|
811
|
+
return parent && membership
|
|
812
|
+
? !isUpdatedElementOf(
|
|
813
|
+
state[membership.variable],
|
|
814
|
+
parent[membership.variable],
|
|
815
|
+
evaluate(membership.set, context),
|
|
816
|
+
)
|
|
817
|
+
: !holdsLikeTlc(invariant.expression, context);
|
|
750
818
|
} catch (error) {
|
|
751
819
|
// TLC reports a failure only on a state after the initial states as an invariant failure.
|
|
752
820
|
if (!parent) throw error;
|
|
@@ -787,7 +855,10 @@ export const createSearch = (
|
|
|
787
855
|
)
|
|
788
856
|
);
|
|
789
857
|
} catch (error) {
|
|
790
|
-
throw withHeadline(
|
|
858
|
+
throw withHeadline(
|
|
859
|
+
withNextStateExitCode(error),
|
|
860
|
+
`Evaluating action property ${property.name} failed.`,
|
|
861
|
+
);
|
|
791
862
|
}
|
|
792
863
|
}),
|
|
793
864
|
satisfiesActionConstraints: (state, next) =>
|
|
@@ -795,8 +866,7 @@ export const createSearch = (
|
|
|
795
866
|
holdsLikeTlc(
|
|
796
867
|
constraint.expression,
|
|
797
868
|
getContext(environment, state, next),
|
|
798
|
-
(expression) =>
|
|
799
|
-
`TLC threw an unexpected exception.\nThis was probably caused by an error in the spec or model.\nSee the User Output or TLC Console for clues to what happened.\nThe exception was a java.lang.RuntimeException\n: ${getExpectedBoolean(expression, environment)}`,
|
|
869
|
+
(expression) => `${UNEXPECTED_EXCEPTION}${getExpectedBoolean(expression, environment)}`,
|
|
800
870
|
),
|
|
801
871
|
),
|
|
802
872
|
trackStatePossible:
|
|
@@ -824,6 +894,11 @@ export const createSearch = (
|
|
|
824
894
|
};
|
|
825
895
|
};
|
|
826
896
|
|
|
897
|
+
// TLC exits with the code of a standard module's failure only when the failure escapes the
|
|
898
|
+
// computation of next states. In every other phase, the phase decides the code.
|
|
899
|
+
const withNextStateExitCode = (error: unknown) =>
|
|
900
|
+
error instanceof TlaModuleError ? setExitCode(error, error.exitCode) : error;
|
|
901
|
+
|
|
827
902
|
const withHeadline = (error: unknown, headline: string) =>
|
|
828
903
|
error instanceof TlaEvaluationError
|
|
829
904
|
? setExitCode(
|
|
@@ -832,8 +907,15 @@ const withHeadline = (error: unknown, headline: string) =>
|
|
|
832
907
|
)
|
|
833
908
|
: error;
|
|
834
909
|
|
|
910
|
+
// TLC finishes the -dump file whether or not the search finds a violation.
|
|
835
911
|
export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
836
|
-
|
|
912
|
+
const stateWriter = options.dump && createStateWriter(options.dump, options.writeFile);
|
|
913
|
+
const result = searchStates(options, stateWriter);
|
|
914
|
+
stateWriter?.close();
|
|
915
|
+
return result;
|
|
916
|
+
};
|
|
917
|
+
|
|
918
|
+
const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefined): CheckResult => {
|
|
837
919
|
const config = typeof options.config === "string" ? parseConfig(options.config) : options.config;
|
|
838
920
|
const onPrint = options.onPrint ?? console.log;
|
|
839
921
|
// TLC prints again while it rebuilds a trace, between the states it prints. Printing those lines
|
|
@@ -929,8 +1011,36 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
929
1011
|
const getFingerprintState = search.getFingerprintState;
|
|
930
1012
|
const nextActions = { value: undefined as SpecAction[] | undefined };
|
|
931
1013
|
const isReducing = config.view !== undefined || config.symmetry !== undefined;
|
|
1014
|
+
const tlcFingerprints: number[] = [];
|
|
932
1015
|
const liveness = withLivenessExitCode(() =>
|
|
933
|
-
createLivenessChecker(search.properties.liveness, spec.temporals, environment
|
|
1016
|
+
createLivenessChecker(search.properties.liveness, spec.temporals, environment, {
|
|
1017
|
+
getFingerprint: (index) =>
|
|
1018
|
+
(tlcFingerprints[index] ??= Number(
|
|
1019
|
+
BigInt.asIntN(32, runtime.getFingerprint(states[index])),
|
|
1020
|
+
)),
|
|
1021
|
+
getSuccessors: (state) => {
|
|
1022
|
+
const successors: LiveSuccessor[] = [];
|
|
1023
|
+
if (spec.next === undefined) return successors;
|
|
1024
|
+
forEachSuccessor(
|
|
1025
|
+
spec.next,
|
|
1026
|
+
state,
|
|
1027
|
+
environment,
|
|
1028
|
+
(successor) => {
|
|
1029
|
+
canonicalizeState(successor.state);
|
|
1030
|
+
const isInModel =
|
|
1031
|
+
search.satisfiesConstraints(successor.state, state) &&
|
|
1032
|
+
search.satisfiesActionConstraints(state, successor.state);
|
|
1033
|
+
if (!isInModel) return false;
|
|
1034
|
+
const fingerprintState = getFingerprintState(successor.state);
|
|
1035
|
+
const index = findStateIndex(getStateHash(fingerprintState), fingerprintState);
|
|
1036
|
+
successors.push({ index, state: successor.state });
|
|
1037
|
+
return false;
|
|
1038
|
+
},
|
|
1039
|
+
spec.scope,
|
|
1040
|
+
);
|
|
1041
|
+
return successors;
|
|
1042
|
+
},
|
|
1043
|
+
}),
|
|
934
1044
|
);
|
|
935
1045
|
const isCanonicalizedFirst = search.isSymmetric || liveness !== undefined;
|
|
936
1046
|
|
|
@@ -939,7 +1049,9 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
939
1049
|
const parents: number[] = [];
|
|
940
1050
|
const actions: (string | undefined)[] = [];
|
|
941
1051
|
const depths: number[] = [];
|
|
942
|
-
|
|
1052
|
+
// A Map holds at most 2^24 entries, so an open-addressing table keeps each seen state's hash
|
|
1053
|
+
// and its index plus one side by side, probed by the hash.
|
|
1054
|
+
const seen = { slots: new Int32Array(1 << 17), size: 0, shift: 16 };
|
|
943
1055
|
const canonicalizeState = createCanonicalizer();
|
|
944
1056
|
|
|
945
1057
|
const toRecord = (state: Value[]): Record<string, Value> =>
|
|
@@ -952,11 +1064,16 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
952
1064
|
position: number,
|
|
953
1065
|
loopStart: number | undefined,
|
|
954
1066
|
) => {
|
|
955
|
-
const state = steps[position].state;
|
|
956
|
-
const next = (steps[position + 1] ?? steps[loopStart ?? position]).state;
|
|
957
1067
|
// TLC evaluates TLCGet("level") and Trace in an alias at the state's position in the trace.
|
|
958
1068
|
runtime.getLevel = () => position + 1;
|
|
959
1069
|
runtime.getBehavior = () => steps.slice(0, position + 1).map((step) => step.state);
|
|
1070
|
+
return evaluateAlias(
|
|
1071
|
+
alias,
|
|
1072
|
+
steps[position].state,
|
|
1073
|
+
(steps[position + 1] ?? steps[loopStart ?? position]).state,
|
|
1074
|
+
);
|
|
1075
|
+
};
|
|
1076
|
+
const evaluateAlias = (alias: string, state: Value[], next: Value[] | undefined) => {
|
|
960
1077
|
try {
|
|
961
1078
|
const body = getConfigDefinition("alias", alias, environment).body;
|
|
962
1079
|
const value = evaluate(createIdentifier(alias), getContext(environment, state, next));
|
|
@@ -1071,7 +1188,7 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
1071
1188
|
outDegrees: failureOutDegrees,
|
|
1072
1189
|
};
|
|
1073
1190
|
};
|
|
1074
|
-
const
|
|
1191
|
+
const getPathSteps = (path: number[], loopStart?: number) => {
|
|
1075
1192
|
const steps = getPathStates(path, NEXT_RECOVERY_FAILURE);
|
|
1076
1193
|
const last = steps[steps.length - 1].state;
|
|
1077
1194
|
const isClosed =
|
|
@@ -1080,7 +1197,7 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
1080
1197
|
loopStart === path.length - 1 ||
|
|
1081
1198
|
findSuccessorWithFingerprint(last, path[loopStart]) !== undefined;
|
|
1082
1199
|
if (!isClosed) throw new TlaEvaluationError(NEXT_RECOVERY_FAILURE);
|
|
1083
|
-
return
|
|
1200
|
+
return steps;
|
|
1084
1201
|
};
|
|
1085
1202
|
const getStateHash = (state: Value[]) => {
|
|
1086
1203
|
let hash = 0x811c9dc5;
|
|
@@ -1094,19 +1211,35 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
1094
1211
|
}
|
|
1095
1212
|
return true;
|
|
1096
1213
|
};
|
|
1214
|
+
const getSlot = (hash: number) => (Math.imul(hash, 0x9e3779b1) >>> seen.shift) << 1;
|
|
1097
1215
|
const findStateIndex = (hash: number, state: Value[]) => {
|
|
1098
|
-
const
|
|
1099
|
-
|
|
1100
|
-
|
|
1101
|
-
|
|
1216
|
+
const mask = seen.slots.length - 1;
|
|
1217
|
+
for (let slot = getSlot(hash); ; slot = (slot + 2) & mask) {
|
|
1218
|
+
const entry = seen.slots[slot + 1];
|
|
1219
|
+
if (entry === 0) return -1;
|
|
1220
|
+
if (seen.slots[slot] === hash && isSameState(fingerprintStates[entry - 1], state)) {
|
|
1221
|
+
return entry - 1;
|
|
1222
|
+
}
|
|
1102
1223
|
}
|
|
1103
|
-
|
|
1224
|
+
};
|
|
1225
|
+
const insertSeen = (hash: number, entry: number) => {
|
|
1226
|
+
const mask = seen.slots.length - 1;
|
|
1227
|
+
let slot = getSlot(hash);
|
|
1228
|
+
while (seen.slots[slot + 1] !== 0) slot = (slot + 2) & mask;
|
|
1229
|
+
seen.slots[slot] = hash;
|
|
1230
|
+
seen.slots[slot + 1] = entry;
|
|
1104
1231
|
};
|
|
1105
1232
|
const markSeen = (hash: number, index: number) => {
|
|
1106
|
-
|
|
1107
|
-
if (
|
|
1108
|
-
|
|
1109
|
-
|
|
1233
|
+
seen.size++;
|
|
1234
|
+
if (seen.size * 4 > seen.slots.length) {
|
|
1235
|
+
const slots = seen.slots;
|
|
1236
|
+
seen.slots = new Int32Array(slots.length * 2);
|
|
1237
|
+
seen.shift--;
|
|
1238
|
+
for (let slot = 0; slot < slots.length; slot += 2) {
|
|
1239
|
+
if (slots[slot + 1] !== 0) insertSeen(slots[slot], slots[slot + 1]);
|
|
1240
|
+
}
|
|
1241
|
+
}
|
|
1242
|
+
insertSeen(hash, index + 1);
|
|
1110
1243
|
};
|
|
1111
1244
|
const countDistinctState = (depth: number) => {
|
|
1112
1245
|
runtime.distinctStates = states.length + 1;
|
|
@@ -1146,7 +1279,7 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
1146
1279
|
};
|
|
1147
1280
|
runtime.getCurrentState = () => (current.index === -1 ? undefined : states[current.index]);
|
|
1148
1281
|
runtime.setLivenessSource = (index) => {
|
|
1149
|
-
current.livenessSource = index;
|
|
1282
|
+
current.livenessSource = index ?? -1;
|
|
1150
1283
|
};
|
|
1151
1284
|
runtime.getLevel = (state) => {
|
|
1152
1285
|
const source = current.livenessSource;
|
|
@@ -1157,6 +1290,18 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
1157
1290
|
return current.isExpanding ? depths[current.index] + 1 : 0;
|
|
1158
1291
|
};
|
|
1159
1292
|
|
|
1293
|
+
const getGraphState = (state: Value[], level: number): GraphState => ({
|
|
1294
|
+
fingerprint: BigInt.asIntN(64, runtime.getFingerprint(state)),
|
|
1295
|
+
level,
|
|
1296
|
+
getLabel: () =>
|
|
1297
|
+
formatState(
|
|
1298
|
+
config.alias === undefined
|
|
1299
|
+
? toRecord(state)
|
|
1300
|
+
: evaluateAlias(config.alias, state, undefined),
|
|
1301
|
+
),
|
|
1302
|
+
getText: () => formatState(toRecord(state)),
|
|
1303
|
+
});
|
|
1304
|
+
|
|
1160
1305
|
const visitInitialState = (state: Value[]) => {
|
|
1161
1306
|
canonicalizeState(state);
|
|
1162
1307
|
runtime.generatedStates++;
|
|
@@ -1173,6 +1318,7 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
1173
1318
|
countDistinctState(1);
|
|
1174
1319
|
runtime.queueSize++;
|
|
1175
1320
|
liveness?.addInitialState(states.length, state);
|
|
1321
|
+
stateWriter?.writeInitialState(getGraphState(state, 1));
|
|
1176
1322
|
}
|
|
1177
1323
|
const violated = search.findViolatedInvariant(state);
|
|
1178
1324
|
if (violated) {
|
|
@@ -1193,7 +1339,13 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
1193
1339
|
addState(state, fingerprintState, -1, undefined);
|
|
1194
1340
|
return undefined;
|
|
1195
1341
|
};
|
|
1196
|
-
const visitSuccessor = (
|
|
1342
|
+
const visitSuccessor = (
|
|
1343
|
+
index: number,
|
|
1344
|
+
successor: Successor,
|
|
1345
|
+
liveSuccessors: LiveSuccessor[],
|
|
1346
|
+
source: GraphState | undefined,
|
|
1347
|
+
action: SpecAction | undefined,
|
|
1348
|
+
) => {
|
|
1197
1349
|
const state = states[index];
|
|
1198
1350
|
runtime.generatedStates++;
|
|
1199
1351
|
current.candidate = successor.state;
|
|
@@ -1207,6 +1359,14 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
1207
1359
|
const isInModel = isStateInModel && search.satisfiesActionConstraints(state, successor.state);
|
|
1208
1360
|
if (isInModel) search.trackActionPossible(state, successor.state);
|
|
1209
1361
|
const existing = isInModel ? found : -1;
|
|
1362
|
+
if (source && isInModel) {
|
|
1363
|
+
stateWriter?.writeSuccessor(
|
|
1364
|
+
source,
|
|
1365
|
+
getGraphState(successor.state, depths[index] + 1),
|
|
1366
|
+
existing !== -1,
|
|
1367
|
+
action && { name: action.name, signature: getActionSignature(action) },
|
|
1368
|
+
);
|
|
1369
|
+
}
|
|
1210
1370
|
if (existing !== -1 && liveness) {
|
|
1211
1371
|
const stored = states[existing];
|
|
1212
1372
|
const isStored = stored.every((value, position) => value === successor.state[position]);
|
|
@@ -1278,23 +1438,55 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
1278
1438
|
}
|
|
1279
1439
|
return createSuccess();
|
|
1280
1440
|
}
|
|
1441
|
+
// TLC labels and colors an edge of the -dump state graph by the action that generated it. When
|
|
1442
|
+
// the graph names its edges, the search generates successors action by action, as TLC does.
|
|
1443
|
+
const isNamingEdges = Boolean(
|
|
1444
|
+
options.dump?.dot && (options.dump.actionLabels || options.dump.colorize),
|
|
1445
|
+
);
|
|
1446
|
+
const forEachActionSuccessor = (
|
|
1447
|
+
state: Value[],
|
|
1448
|
+
onSuccessor: (successor: Successor, action: SpecAction | undefined) => boolean,
|
|
1449
|
+
) => {
|
|
1450
|
+
if (!isNamingEdges) {
|
|
1451
|
+
return forEachSuccessor(
|
|
1452
|
+
next,
|
|
1453
|
+
state,
|
|
1454
|
+
environment,
|
|
1455
|
+
(successor) => onSuccessor(successor, undefined),
|
|
1456
|
+
spec.scope,
|
|
1457
|
+
);
|
|
1458
|
+
}
|
|
1459
|
+
nextActions.value ??= getNextActions(config, environment, specification.instanceActions);
|
|
1460
|
+
const progress = { isStopped: false };
|
|
1461
|
+
return nextActions.value.reduce((count, action) => {
|
|
1462
|
+
if (progress.isStopped) return count;
|
|
1463
|
+
return (
|
|
1464
|
+
count +
|
|
1465
|
+
forEachSuccessor(
|
|
1466
|
+
action.expression,
|
|
1467
|
+
state,
|
|
1468
|
+
environment,
|
|
1469
|
+
(successor) => {
|
|
1470
|
+
progress.isStopped = onSuccessor(successor, action);
|
|
1471
|
+
return progress.isStopped;
|
|
1472
|
+
},
|
|
1473
|
+
action.scope,
|
|
1474
|
+
)
|
|
1475
|
+
);
|
|
1476
|
+
}, 0);
|
|
1477
|
+
};
|
|
1281
1478
|
const expandState = (index: number) => {
|
|
1282
1479
|
const state = states[index];
|
|
1283
1480
|
const liveSuccessors: LiveSuccessor[] = [];
|
|
1284
|
-
const
|
|
1285
|
-
|
|
1286
|
-
|
|
1287
|
-
|
|
1288
|
-
(
|
|
1289
|
-
|
|
1290
|
-
|
|
1291
|
-
|
|
1292
|
-
|
|
1293
|
-
}
|
|
1294
|
-
return outcome.result !== undefined;
|
|
1295
|
-
},
|
|
1296
|
-
spec.scope,
|
|
1297
|
-
);
|
|
1481
|
+
const source = stateWriter && getGraphState(state, depths[index]);
|
|
1482
|
+
const successorCount = forEachActionSuccessor(state, (successor, action) => {
|
|
1483
|
+
try {
|
|
1484
|
+
outcome.result = visitSuccessor(index, successor, liveSuccessors, source, action);
|
|
1485
|
+
} catch (error) {
|
|
1486
|
+
outcome.result = toFailure(error, getTrace(index, successor));
|
|
1487
|
+
}
|
|
1488
|
+
return outcome.result !== undefined;
|
|
1489
|
+
});
|
|
1298
1490
|
current.isExpanding = false;
|
|
1299
1491
|
if (outcome.result) return outcome.result;
|
|
1300
1492
|
if (successorCount === 0 && config.checkDeadlock) {
|
|
@@ -1302,32 +1494,43 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
1302
1494
|
}
|
|
1303
1495
|
try {
|
|
1304
1496
|
const accepted = liveness?.addState(index, state, liveSuccessors);
|
|
1305
|
-
|
|
1306
|
-
|
|
1497
|
+
if (!liveness || !accepted) return undefined;
|
|
1498
|
+
const steps = getPathSteps(accepted);
|
|
1499
|
+
const properties = liveness.getViolatedProperties(
|
|
1500
|
+
steps.map((step) => step.state),
|
|
1501
|
+
steps.length - 1,
|
|
1502
|
+
);
|
|
1307
1503
|
return reportViolation("property-violation", {
|
|
1308
|
-
name:
|
|
1309
|
-
|
|
1504
|
+
name: properties[0],
|
|
1505
|
+
properties,
|
|
1506
|
+
trace: toTrace(steps, accepted),
|
|
1310
1507
|
});
|
|
1311
1508
|
} catch (error) {
|
|
1312
1509
|
return toFailure(error, getStateTrace(index), undefined, getPartialOutDegrees());
|
|
1313
1510
|
}
|
|
1314
1511
|
};
|
|
1315
|
-
|
|
1512
|
+
// TLC names the properties and the step back into the cycle from the states it prints.
|
|
1513
|
+
const reportLasso = (checker: LivenessChecker, lasso: Lasso) => {
|
|
1316
1514
|
const path = [...lasso.prefix, ...lasso.cycle];
|
|
1317
|
-
const
|
|
1318
|
-
const
|
|
1515
|
+
const loopStart = lasso.prefix.length;
|
|
1516
|
+
const steps = getPathSteps(path, loopStart);
|
|
1517
|
+
const trace = toTrace(steps, path, loopStart);
|
|
1518
|
+
const properties = checker.getViolatedProperties(
|
|
1519
|
+
steps.map((step) => step.state),
|
|
1520
|
+
loopStart,
|
|
1521
|
+
);
|
|
1522
|
+
const back = path[loopStart];
|
|
1319
1523
|
const last = path[path.length - 1];
|
|
1524
|
+
const lastState = steps[steps.length - 1].state;
|
|
1320
1525
|
const loopLabel =
|
|
1321
|
-
back === last ? undefined : withoutOutput(() => getLabel(last,
|
|
1526
|
+
back === last ? undefined : withoutOutput(() => getLabel(last, lastState, states[back]));
|
|
1322
1527
|
return reportViolation(
|
|
1323
1528
|
"liveness-violation",
|
|
1324
|
-
{ name:
|
|
1529
|
+
{ name: properties[0], properties, trace, loopStart, loopLabel },
|
|
1325
1530
|
() =>
|
|
1326
1531
|
back === last
|
|
1327
1532
|
? trace[trace.length - 1].action
|
|
1328
|
-
:
|
|
1329
|
-
isSameState(successor.state, states[back]),
|
|
1330
|
-
)?.action,
|
|
1533
|
+
: findSuccessorWithFingerprint(lastState, back)?.action,
|
|
1331
1534
|
);
|
|
1332
1535
|
};
|
|
1333
1536
|
const isPeriodic = liveness !== undefined && options.livenessCheck !== "final";
|
|
@@ -1340,11 +1543,9 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
1340
1543
|
if (!isGrown || periodic.time > (now - startedAt) * LIVENESS_RATIO) return undefined;
|
|
1341
1544
|
periodic.size = expanded;
|
|
1342
1545
|
const lasso = liveness?.findViolation();
|
|
1343
|
-
current.livenessSource = -1;
|
|
1344
1546
|
periodic.time += performance.now() - now;
|
|
1345
1547
|
return lasso;
|
|
1346
1548
|
};
|
|
1347
|
-
setNextStatePhase(true);
|
|
1348
1549
|
for (let index = 0; index < states.length && !runtime.isStopped; index++) {
|
|
1349
1550
|
current.index = index;
|
|
1350
1551
|
current.candidate = undefined;
|
|
@@ -1353,22 +1554,21 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
1353
1554
|
try {
|
|
1354
1555
|
outcome.result = expandState(index);
|
|
1355
1556
|
} catch (error) {
|
|
1356
|
-
outcome.result = toFailure(error, getStateTrace(index));
|
|
1557
|
+
outcome.result = toFailure(withNextStateExitCode(error), getStateTrace(index));
|
|
1357
1558
|
}
|
|
1358
1559
|
if (outcome.result) return outcome.result;
|
|
1359
1560
|
outDegrees[getOutDegreeBucket()]++;
|
|
1360
1561
|
expansion.newStates = 0;
|
|
1361
1562
|
if (isPeriodic && performance.now() >= periodic.at) {
|
|
1362
1563
|
const lasso = findPeriodicViolation(index + 1);
|
|
1363
|
-
if (lasso) return reportLasso(lasso);
|
|
1564
|
+
if (liveness && lasso) return reportLasso(liveness, lasso);
|
|
1364
1565
|
}
|
|
1365
1566
|
}
|
|
1366
1567
|
|
|
1367
1568
|
current.index = -1;
|
|
1368
1569
|
current.candidate = undefined;
|
|
1369
1570
|
const lasso = liveness?.findViolation();
|
|
1370
|
-
|
|
1371
|
-
if (lasso) return reportLasso(lasso);
|
|
1571
|
+
if (liveness && lasso) return reportLasso(liveness, lasso);
|
|
1372
1572
|
|
|
1373
1573
|
const postconditionViolation = search.findPostconditionViolation();
|
|
1374
1574
|
if (postconditionViolation) {
|