tla-ts 0.0.3-dev.a50fc89 → 0.0.3-dev.a57ca4f
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 +22 -2
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +10 -0
- package/dist/index.d.ts +10 -0
- 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 +18 -17
- package/dist/run-cli.js +14 -13
- package/dist/transfer.cjs +27 -15
- package/dist/transfer.js +27 -15
- package/package.json +1 -1
- package/src/ast.ts +90 -0
- package/src/check.ts +233 -68
- package/src/cli-options.ts +11 -5
- package/src/codegen.ts +9 -19
- package/src/dependencies.ts +2 -2
- package/src/environment.ts +75 -16
- package/src/errors.ts +9 -2
- package/src/evaluate.ts +84 -141
- 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 +5 -1
- package/src/live-check.ts +711 -0
- package/src/liveness.ts +54 -535
- package/src/parallel-worker.ts +166 -210
- package/src/parallel.ts +76 -35
- package/src/parser.ts +12 -1
- package/src/resolve.ts +16 -15
- package/src/run-cli.ts +58 -13
- package/src/runtime.ts +3 -1
- package/src/spec-description.ts +18 -6
- package/src/standard-modules.ts +2 -7
- package/src/state-graph.ts +157 -0
- package/src/subexpressions.ts +10 -10
- package/src/successors.ts +66 -9
- package/src/symmetry.ts +14 -2
- package/src/tlc-ext.ts +29 -12
- package/src/tlc-module.ts +9 -28
- package/src/tlc-order.ts +17 -3
- package/src/values.ts +40 -11
package/package.json
CHANGED
package/src/ast.ts
CHANGED
|
@@ -486,3 +486,93 @@ export interface Module {
|
|
|
486
486
|
uses: UseOrHide[];
|
|
487
487
|
units: ModuleUnit[];
|
|
488
488
|
}
|
|
489
|
+
|
|
490
|
+
export const getChildren = (expression: Expression): Expression[] => {
|
|
491
|
+
switch (expression.kind) {
|
|
492
|
+
case "Number":
|
|
493
|
+
case "Decimal":
|
|
494
|
+
case "String":
|
|
495
|
+
case "Identifier":
|
|
496
|
+
case "OperatorReference":
|
|
497
|
+
case "ExceptAt":
|
|
498
|
+
return [];
|
|
499
|
+
case "Apply":
|
|
500
|
+
return expression.args;
|
|
501
|
+
case "Lambda":
|
|
502
|
+
return [expression.body];
|
|
503
|
+
case "And":
|
|
504
|
+
case "Or":
|
|
505
|
+
return expression.operands;
|
|
506
|
+
case "Prime":
|
|
507
|
+
case "Unchanged":
|
|
508
|
+
case "Enabled":
|
|
509
|
+
case "Always":
|
|
510
|
+
case "Eventually":
|
|
511
|
+
return [expression.expression];
|
|
512
|
+
case "If":
|
|
513
|
+
return [expression.condition, expression.consequent, expression.alternative];
|
|
514
|
+
case "Case":
|
|
515
|
+
return [
|
|
516
|
+
...expression.arms.flatMap((arm) => [arm.condition, arm.body]),
|
|
517
|
+
...(expression.other ? [expression.other] : []),
|
|
518
|
+
];
|
|
519
|
+
case "Let":
|
|
520
|
+
return [
|
|
521
|
+
...expression.definitions.flatMap((definition) =>
|
|
522
|
+
definition.kind === "Function"
|
|
523
|
+
? [...definition.bounds.map((bound) => bound.set), definition.body]
|
|
524
|
+
: [definition.body],
|
|
525
|
+
),
|
|
526
|
+
expression.body,
|
|
527
|
+
];
|
|
528
|
+
case "Forall":
|
|
529
|
+
case "Exists":
|
|
530
|
+
return [...expression.bounds.map((bound) => bound.set), expression.body];
|
|
531
|
+
case "UnboundedQuantifier":
|
|
532
|
+
return [expression.body];
|
|
533
|
+
case "Choose":
|
|
534
|
+
return [...(expression.set ? [expression.set] : []), expression.body];
|
|
535
|
+
case "SetEnumeration":
|
|
536
|
+
case "Tuple":
|
|
537
|
+
return expression.elements;
|
|
538
|
+
case "SetFilter":
|
|
539
|
+
return [expression.bound.set, expression.predicate];
|
|
540
|
+
case "SetMap":
|
|
541
|
+
return [expression.expression, ...expression.bounds.map((bound) => bound.set)];
|
|
542
|
+
case "FunctionConstruction":
|
|
543
|
+
return [...expression.bounds.map((bound) => bound.set), expression.body];
|
|
544
|
+
case "FunctionSet":
|
|
545
|
+
return [expression.domain, expression.range];
|
|
546
|
+
case "Record":
|
|
547
|
+
case "RecordSet":
|
|
548
|
+
return expression.fields.map((field) => field.value);
|
|
549
|
+
case "Except":
|
|
550
|
+
return [
|
|
551
|
+
expression.function,
|
|
552
|
+
...expression.updates.flatMap((update) => [
|
|
553
|
+
...update.path.flatMap((step) => (step.kind === "Index" ? step.args : [])),
|
|
554
|
+
update.value,
|
|
555
|
+
]),
|
|
556
|
+
];
|
|
557
|
+
case "FunctionApplication":
|
|
558
|
+
return [expression.function, ...expression.args];
|
|
559
|
+
case "FieldAccess":
|
|
560
|
+
return [expression.record];
|
|
561
|
+
case "Product":
|
|
562
|
+
return expression.factors;
|
|
563
|
+
case "BoxAction":
|
|
564
|
+
case "AngleAction":
|
|
565
|
+
return [expression.action, expression.subscript];
|
|
566
|
+
case "WeakFairness":
|
|
567
|
+
case "StrongFairness":
|
|
568
|
+
return [expression.subscript, expression.action];
|
|
569
|
+
case "Label":
|
|
570
|
+
return [expression.body];
|
|
571
|
+
case "Subexpression":
|
|
572
|
+
return expression.selectors.flatMap((selector) => ("args" in selector ? selector.args : []));
|
|
573
|
+
}
|
|
574
|
+
};
|
|
575
|
+
|
|
576
|
+
export const isLocallyResolved = (expression: Expression) =>
|
|
577
|
+
(expression.kind === "Identifier" || expression.kind === "Apply") &&
|
|
578
|
+
expression.resolution?.kind === "Local";
|
package/src/check.ts
CHANGED
|
@@ -1,32 +1,41 @@
|
|
|
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,
|
|
16
|
-
isLocallyResolved,
|
|
17
28
|
type Context,
|
|
18
29
|
type Environment,
|
|
19
30
|
type Scope,
|
|
20
31
|
} from "./evaluate";
|
|
21
32
|
import {
|
|
22
33
|
createLivenessChecker,
|
|
23
|
-
expandTemporal,
|
|
24
|
-
getLevel,
|
|
25
34
|
type Lasso,
|
|
35
|
+
type LivenessChecker,
|
|
26
36
|
type LiveSuccessor,
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
} from "./liveness";
|
|
37
|
+
} from "./live-check";
|
|
38
|
+
import { expandTemporal, getLevel, type ScopedExpression, type TemporalProperty } from "./liveness";
|
|
30
39
|
import { ACTION_LEVEL, createLevelAnalyzer, TEMPORAL_LEVEL } from "./levels";
|
|
31
40
|
import { prettyPrint } from "./pretty-print";
|
|
32
41
|
import {
|
|
@@ -38,10 +47,17 @@ import {
|
|
|
38
47
|
} from "./successors";
|
|
39
48
|
import {
|
|
40
49
|
getActionLabel,
|
|
50
|
+
getActionSignature,
|
|
41
51
|
getNextActions,
|
|
42
52
|
getSpecificationValue,
|
|
43
53
|
type SpecAction,
|
|
44
54
|
} from "./spec-description";
|
|
55
|
+
import {
|
|
56
|
+
createStateWriter,
|
|
57
|
+
type GraphState,
|
|
58
|
+
type StateDump,
|
|
59
|
+
type StateWriter,
|
|
60
|
+
} from "./state-graph";
|
|
45
61
|
import { getRepresentative, getSymmetryGroup } from "./symmetry";
|
|
46
62
|
import { getTlcStringOrder, getTlcVariableOrder } from "./tlc-order";
|
|
47
63
|
import { createTlcFingerprinter, getTlcFingerprint } from "./tlc-random";
|
|
@@ -51,6 +67,7 @@ import { createCounterExample } from "./tlc-ext";
|
|
|
51
67
|
import { getFingerprintDistance, OUT_DEGREE_BUCKETS } from "./tlc-summary";
|
|
52
68
|
import {
|
|
53
69
|
combineHash,
|
|
70
|
+
formatState,
|
|
54
71
|
formatValue,
|
|
55
72
|
getValueHash,
|
|
56
73
|
isFunctionValue,
|
|
@@ -74,6 +91,8 @@ export interface CheckOptions {
|
|
|
74
91
|
workers?: number;
|
|
75
92
|
// TLC's -lncheck: "final" checks liveness only on the complete state graph.
|
|
76
93
|
livenessCheck?: "default" | "final";
|
|
94
|
+
// TLC's -dump: writes the reachable states, or with `dot` the state graph, through writeFile.
|
|
95
|
+
dump?: StateDump;
|
|
77
96
|
}
|
|
78
97
|
|
|
79
98
|
export type CheckStatus =
|
|
@@ -95,6 +114,8 @@ export interface TraceStep {
|
|
|
95
114
|
|
|
96
115
|
export interface Violation {
|
|
97
116
|
name: string;
|
|
117
|
+
// Every temporal property that a liveness counterexample violates, in the configuration's order.
|
|
118
|
+
properties?: string[];
|
|
98
119
|
trace: TraceStep[];
|
|
99
120
|
loopStart: number | undefined;
|
|
100
121
|
loopLabel?: string;
|
|
@@ -425,12 +446,12 @@ const getProperties = (config: ModelConfig, environment: Environment): Propertie
|
|
|
425
446
|
config.properties.forEach((name) => {
|
|
426
447
|
const definition = getConfigPredicate("property", name, environment);
|
|
427
448
|
if (!definition) return;
|
|
428
|
-
expandTemporal(definition.body, undefined, environment, true).forEach((item) => {
|
|
449
|
+
expandTemporal(definition.body, undefined, environment, true, name).forEach((item) => {
|
|
429
450
|
const conjunct = item.expression;
|
|
430
451
|
if (isConstantTrue(item, environment, "property")) return;
|
|
431
452
|
if (conjunct.kind === "Always" && conjunct.expression.kind === "BoxAction") {
|
|
432
453
|
properties.actionProperties.push({
|
|
433
|
-
name,
|
|
454
|
+
name: item.name,
|
|
434
455
|
box: conjunct.expression,
|
|
435
456
|
action: conjunct.expression.action,
|
|
436
457
|
subscript: conjunct.expression.subscript,
|
|
@@ -442,12 +463,22 @@ const getProperties = (config: ModelConfig, environment: Environment): Propertie
|
|
|
442
463
|
conjunct.kind === "Always" &&
|
|
443
464
|
getLevel(conjunct.expression, item.scope, environment) <= 1
|
|
444
465
|
) {
|
|
445
|
-
|
|
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
|
+
});
|
|
446
473
|
return;
|
|
447
474
|
}
|
|
448
475
|
const level = getLevel(conjunct, item.scope, environment);
|
|
449
476
|
if (level < ACTION_LEVEL) {
|
|
450
|
-
properties.initialPredicates.push({
|
|
477
|
+
properties.initialPredicates.push({
|
|
478
|
+
name: item.name,
|
|
479
|
+
expression: conjunct,
|
|
480
|
+
scope: item.scope,
|
|
481
|
+
});
|
|
451
482
|
return;
|
|
452
483
|
}
|
|
453
484
|
if (level === ACTION_LEVEL) {
|
|
@@ -507,7 +538,9 @@ const getMembership = (
|
|
|
507
538
|
const getStateChecks = (named: NamedExpression[], environment: Environment): StateCheck[] =>
|
|
508
539
|
named.flatMap((item) =>
|
|
509
540
|
getConjuncts(item.expression, environment).map((expression) => {
|
|
510
|
-
|
|
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;
|
|
511
544
|
return {
|
|
512
545
|
name: item.name,
|
|
513
546
|
expression,
|
|
@@ -820,7 +853,10 @@ export const createSearch = (
|
|
|
820
853
|
)
|
|
821
854
|
);
|
|
822
855
|
} catch (error) {
|
|
823
|
-
throw withHeadline(
|
|
856
|
+
throw withHeadline(
|
|
857
|
+
withNextStateExitCode(error),
|
|
858
|
+
`Evaluating action property ${property.name} failed.`,
|
|
859
|
+
);
|
|
824
860
|
}
|
|
825
861
|
}),
|
|
826
862
|
satisfiesActionConstraints: (state, next) =>
|
|
@@ -828,8 +864,7 @@ export const createSearch = (
|
|
|
828
864
|
holdsLikeTlc(
|
|
829
865
|
constraint.expression,
|
|
830
866
|
getContext(environment, state, next),
|
|
831
|
-
(expression) =>
|
|
832
|
-
`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)}`,
|
|
867
|
+
(expression) => `${UNEXPECTED_EXCEPTION}${getExpectedBoolean(expression, environment)}`,
|
|
833
868
|
),
|
|
834
869
|
),
|
|
835
870
|
trackStatePossible:
|
|
@@ -857,6 +892,11 @@ export const createSearch = (
|
|
|
857
892
|
};
|
|
858
893
|
};
|
|
859
894
|
|
|
895
|
+
// TLC exits with the code of a standard module's failure only when the failure escapes the
|
|
896
|
+
// computation of next states. In every other phase, the phase decides the code.
|
|
897
|
+
const withNextStateExitCode = (error: unknown) =>
|
|
898
|
+
error instanceof TlaModuleError ? setExitCode(error, error.exitCode) : error;
|
|
899
|
+
|
|
860
900
|
const withHeadline = (error: unknown, headline: string) =>
|
|
861
901
|
error instanceof TlaEvaluationError
|
|
862
902
|
? setExitCode(
|
|
@@ -865,8 +905,15 @@ const withHeadline = (error: unknown, headline: string) =>
|
|
|
865
905
|
)
|
|
866
906
|
: error;
|
|
867
907
|
|
|
908
|
+
// TLC finishes the -dump file whether or not the search finds a violation.
|
|
868
909
|
export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
869
|
-
|
|
910
|
+
const stateWriter = options.dump && createStateWriter(options.dump, options.writeFile);
|
|
911
|
+
const result = searchStates(options, stateWriter);
|
|
912
|
+
stateWriter?.close();
|
|
913
|
+
return result;
|
|
914
|
+
};
|
|
915
|
+
|
|
916
|
+
const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefined): CheckResult => {
|
|
870
917
|
const config = typeof options.config === "string" ? parseConfig(options.config) : options.config;
|
|
871
918
|
const onPrint = options.onPrint ?? console.log;
|
|
872
919
|
// TLC prints again while it rebuilds a trace, between the states it prints. Printing those lines
|
|
@@ -962,8 +1009,36 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
962
1009
|
const getFingerprintState = search.getFingerprintState;
|
|
963
1010
|
const nextActions = { value: undefined as SpecAction[] | undefined };
|
|
964
1011
|
const isReducing = config.view !== undefined || config.symmetry !== undefined;
|
|
1012
|
+
const tlcFingerprints: number[] = [];
|
|
965
1013
|
const liveness = withLivenessExitCode(() =>
|
|
966
|
-
createLivenessChecker(search.properties.liveness, spec.temporals, environment
|
|
1014
|
+
createLivenessChecker(search.properties.liveness, spec.temporals, environment, {
|
|
1015
|
+
getFingerprint: (index) =>
|
|
1016
|
+
(tlcFingerprints[index] ??= Number(
|
|
1017
|
+
BigInt.asIntN(32, runtime.getFingerprint(states[index])),
|
|
1018
|
+
)),
|
|
1019
|
+
getSuccessors: (state) => {
|
|
1020
|
+
const successors: LiveSuccessor[] = [];
|
|
1021
|
+
if (spec.next === undefined) return successors;
|
|
1022
|
+
forEachSuccessor(
|
|
1023
|
+
spec.next,
|
|
1024
|
+
state,
|
|
1025
|
+
environment,
|
|
1026
|
+
(successor) => {
|
|
1027
|
+
canonicalizeState(successor.state);
|
|
1028
|
+
const isInModel =
|
|
1029
|
+
search.satisfiesConstraints(successor.state, state) &&
|
|
1030
|
+
search.satisfiesActionConstraints(state, successor.state);
|
|
1031
|
+
if (!isInModel) return false;
|
|
1032
|
+
const fingerprintState = getFingerprintState(successor.state);
|
|
1033
|
+
const index = findStateIndex(getStateHash(fingerprintState), fingerprintState);
|
|
1034
|
+
successors.push({ index, state: successor.state });
|
|
1035
|
+
return false;
|
|
1036
|
+
},
|
|
1037
|
+
spec.scope,
|
|
1038
|
+
);
|
|
1039
|
+
return successors;
|
|
1040
|
+
},
|
|
1041
|
+
}),
|
|
967
1042
|
);
|
|
968
1043
|
const isCanonicalizedFirst = search.isSymmetric || liveness !== undefined;
|
|
969
1044
|
|
|
@@ -972,7 +1047,9 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
972
1047
|
const parents: number[] = [];
|
|
973
1048
|
const actions: (string | undefined)[] = [];
|
|
974
1049
|
const depths: number[] = [];
|
|
975
|
-
|
|
1050
|
+
// A Map holds at most 2^24 entries, so an open-addressing table keeps each seen state's hash
|
|
1051
|
+
// and its index plus one side by side, probed by the hash.
|
|
1052
|
+
const seen = { slots: new Int32Array(1 << 17), size: 0, shift: 16 };
|
|
976
1053
|
const canonicalizeState = createCanonicalizer();
|
|
977
1054
|
|
|
978
1055
|
const toRecord = (state: Value[]): Record<string, Value> =>
|
|
@@ -985,11 +1062,16 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
985
1062
|
position: number,
|
|
986
1063
|
loopStart: number | undefined,
|
|
987
1064
|
) => {
|
|
988
|
-
const state = steps[position].state;
|
|
989
|
-
const next = (steps[position + 1] ?? steps[loopStart ?? position]).state;
|
|
990
1065
|
// TLC evaluates TLCGet("level") and Trace in an alias at the state's position in the trace.
|
|
991
1066
|
runtime.getLevel = () => position + 1;
|
|
992
1067
|
runtime.getBehavior = () => steps.slice(0, position + 1).map((step) => step.state);
|
|
1068
|
+
return evaluateAlias(
|
|
1069
|
+
alias,
|
|
1070
|
+
steps[position].state,
|
|
1071
|
+
(steps[position + 1] ?? steps[loopStart ?? position]).state,
|
|
1072
|
+
);
|
|
1073
|
+
};
|
|
1074
|
+
const evaluateAlias = (alias: string, state: Value[], next: Value[] | undefined) => {
|
|
993
1075
|
try {
|
|
994
1076
|
const body = getConfigDefinition("alias", alias, environment).body;
|
|
995
1077
|
const value = evaluate(createIdentifier(alias), getContext(environment, state, next));
|
|
@@ -1104,7 +1186,7 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
1104
1186
|
outDegrees: failureOutDegrees,
|
|
1105
1187
|
};
|
|
1106
1188
|
};
|
|
1107
|
-
const
|
|
1189
|
+
const getPathSteps = (path: number[], loopStart?: number) => {
|
|
1108
1190
|
const steps = getPathStates(path, NEXT_RECOVERY_FAILURE);
|
|
1109
1191
|
const last = steps[steps.length - 1].state;
|
|
1110
1192
|
const isClosed =
|
|
@@ -1113,7 +1195,7 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
1113
1195
|
loopStart === path.length - 1 ||
|
|
1114
1196
|
findSuccessorWithFingerprint(last, path[loopStart]) !== undefined;
|
|
1115
1197
|
if (!isClosed) throw new TlaEvaluationError(NEXT_RECOVERY_FAILURE);
|
|
1116
|
-
return
|
|
1198
|
+
return steps;
|
|
1117
1199
|
};
|
|
1118
1200
|
const getStateHash = (state: Value[]) => {
|
|
1119
1201
|
let hash = 0x811c9dc5;
|
|
@@ -1127,19 +1209,35 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
1127
1209
|
}
|
|
1128
1210
|
return true;
|
|
1129
1211
|
};
|
|
1212
|
+
const getSlot = (hash: number) => (Math.imul(hash, 0x9e3779b1) >>> seen.shift) << 1;
|
|
1130
1213
|
const findStateIndex = (hash: number, state: Value[]) => {
|
|
1131
|
-
const
|
|
1132
|
-
|
|
1133
|
-
|
|
1134
|
-
|
|
1214
|
+
const mask = seen.slots.length - 1;
|
|
1215
|
+
for (let slot = getSlot(hash); ; slot = (slot + 2) & mask) {
|
|
1216
|
+
const entry = seen.slots[slot + 1];
|
|
1217
|
+
if (entry === 0) return -1;
|
|
1218
|
+
if (seen.slots[slot] === hash && isSameState(fingerprintStates[entry - 1], state)) {
|
|
1219
|
+
return entry - 1;
|
|
1220
|
+
}
|
|
1135
1221
|
}
|
|
1136
|
-
|
|
1222
|
+
};
|
|
1223
|
+
const insertSeen = (hash: number, entry: number) => {
|
|
1224
|
+
const mask = seen.slots.length - 1;
|
|
1225
|
+
let slot = getSlot(hash);
|
|
1226
|
+
while (seen.slots[slot + 1] !== 0) slot = (slot + 2) & mask;
|
|
1227
|
+
seen.slots[slot] = hash;
|
|
1228
|
+
seen.slots[slot + 1] = entry;
|
|
1137
1229
|
};
|
|
1138
1230
|
const markSeen = (hash: number, index: number) => {
|
|
1139
|
-
|
|
1140
|
-
if (
|
|
1141
|
-
|
|
1142
|
-
|
|
1231
|
+
seen.size++;
|
|
1232
|
+
if (seen.size * 4 > seen.slots.length) {
|
|
1233
|
+
const slots = seen.slots;
|
|
1234
|
+
seen.slots = new Int32Array(slots.length * 2);
|
|
1235
|
+
seen.shift--;
|
|
1236
|
+
for (let slot = 0; slot < slots.length; slot += 2) {
|
|
1237
|
+
if (slots[slot + 1] !== 0) insertSeen(slots[slot], slots[slot + 1]);
|
|
1238
|
+
}
|
|
1239
|
+
}
|
|
1240
|
+
insertSeen(hash, index + 1);
|
|
1143
1241
|
};
|
|
1144
1242
|
const countDistinctState = (depth: number) => {
|
|
1145
1243
|
runtime.distinctStates = states.length + 1;
|
|
@@ -1179,7 +1277,7 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
1179
1277
|
};
|
|
1180
1278
|
runtime.getCurrentState = () => (current.index === -1 ? undefined : states[current.index]);
|
|
1181
1279
|
runtime.setLivenessSource = (index) => {
|
|
1182
|
-
current.livenessSource = index;
|
|
1280
|
+
current.livenessSource = index ?? -1;
|
|
1183
1281
|
};
|
|
1184
1282
|
runtime.getLevel = (state) => {
|
|
1185
1283
|
const source = current.livenessSource;
|
|
@@ -1190,6 +1288,18 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
1190
1288
|
return current.isExpanding ? depths[current.index] + 1 : 0;
|
|
1191
1289
|
};
|
|
1192
1290
|
|
|
1291
|
+
const getGraphState = (state: Value[], level: number): GraphState => ({
|
|
1292
|
+
fingerprint: BigInt.asIntN(64, runtime.getFingerprint(state)),
|
|
1293
|
+
level,
|
|
1294
|
+
getLabel: () =>
|
|
1295
|
+
formatState(
|
|
1296
|
+
config.alias === undefined
|
|
1297
|
+
? toRecord(state)
|
|
1298
|
+
: evaluateAlias(config.alias, state, undefined),
|
|
1299
|
+
),
|
|
1300
|
+
getText: () => formatState(toRecord(state)),
|
|
1301
|
+
});
|
|
1302
|
+
|
|
1193
1303
|
const visitInitialState = (state: Value[]) => {
|
|
1194
1304
|
canonicalizeState(state);
|
|
1195
1305
|
runtime.generatedStates++;
|
|
@@ -1206,6 +1316,7 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
1206
1316
|
countDistinctState(1);
|
|
1207
1317
|
runtime.queueSize++;
|
|
1208
1318
|
liveness?.addInitialState(states.length, state);
|
|
1319
|
+
stateWriter?.writeInitialState(getGraphState(state, 1));
|
|
1209
1320
|
}
|
|
1210
1321
|
const violated = search.findViolatedInvariant(state);
|
|
1211
1322
|
if (violated) {
|
|
@@ -1226,7 +1337,13 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
1226
1337
|
addState(state, fingerprintState, -1, undefined);
|
|
1227
1338
|
return undefined;
|
|
1228
1339
|
};
|
|
1229
|
-
const visitSuccessor = (
|
|
1340
|
+
const visitSuccessor = (
|
|
1341
|
+
index: number,
|
|
1342
|
+
successor: Successor,
|
|
1343
|
+
liveSuccessors: LiveSuccessor[],
|
|
1344
|
+
source: GraphState | undefined,
|
|
1345
|
+
action: SpecAction | undefined,
|
|
1346
|
+
) => {
|
|
1230
1347
|
const state = states[index];
|
|
1231
1348
|
runtime.generatedStates++;
|
|
1232
1349
|
current.candidate = successor.state;
|
|
@@ -1240,6 +1357,14 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
1240
1357
|
const isInModel = isStateInModel && search.satisfiesActionConstraints(state, successor.state);
|
|
1241
1358
|
if (isInModel) search.trackActionPossible(state, successor.state);
|
|
1242
1359
|
const existing = isInModel ? found : -1;
|
|
1360
|
+
if (source && isInModel) {
|
|
1361
|
+
stateWriter?.writeSuccessor(
|
|
1362
|
+
source,
|
|
1363
|
+
getGraphState(successor.state, depths[index] + 1),
|
|
1364
|
+
existing !== -1,
|
|
1365
|
+
action && { name: action.name, signature: getActionSignature(action) },
|
|
1366
|
+
);
|
|
1367
|
+
}
|
|
1243
1368
|
if (existing !== -1 && liveness) {
|
|
1244
1369
|
const stored = states[existing];
|
|
1245
1370
|
const isStored = stored.every((value, position) => value === successor.state[position]);
|
|
@@ -1311,23 +1436,55 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
1311
1436
|
}
|
|
1312
1437
|
return createSuccess();
|
|
1313
1438
|
}
|
|
1439
|
+
// TLC labels and colors an edge of the -dump state graph by the action that generated it. When
|
|
1440
|
+
// the graph names its edges, the search generates successors action by action, as TLC does.
|
|
1441
|
+
const isNamingEdges = Boolean(
|
|
1442
|
+
options.dump?.dot && (options.dump.actionLabels || options.dump.colorize),
|
|
1443
|
+
);
|
|
1444
|
+
const forEachActionSuccessor = (
|
|
1445
|
+
state: Value[],
|
|
1446
|
+
onSuccessor: (successor: Successor, action: SpecAction | undefined) => boolean,
|
|
1447
|
+
) => {
|
|
1448
|
+
if (!isNamingEdges) {
|
|
1449
|
+
return forEachSuccessor(
|
|
1450
|
+
next,
|
|
1451
|
+
state,
|
|
1452
|
+
environment,
|
|
1453
|
+
(successor) => onSuccessor(successor, undefined),
|
|
1454
|
+
spec.scope,
|
|
1455
|
+
);
|
|
1456
|
+
}
|
|
1457
|
+
nextActions.value ??= getNextActions(config, environment, specification.instanceActions);
|
|
1458
|
+
const progress = { isStopped: false };
|
|
1459
|
+
return nextActions.value.reduce((count, action) => {
|
|
1460
|
+
if (progress.isStopped) return count;
|
|
1461
|
+
return (
|
|
1462
|
+
count +
|
|
1463
|
+
forEachSuccessor(
|
|
1464
|
+
action.expression,
|
|
1465
|
+
state,
|
|
1466
|
+
environment,
|
|
1467
|
+
(successor) => {
|
|
1468
|
+
progress.isStopped = onSuccessor(successor, action);
|
|
1469
|
+
return progress.isStopped;
|
|
1470
|
+
},
|
|
1471
|
+
action.scope,
|
|
1472
|
+
)
|
|
1473
|
+
);
|
|
1474
|
+
}, 0);
|
|
1475
|
+
};
|
|
1314
1476
|
const expandState = (index: number) => {
|
|
1315
1477
|
const state = states[index];
|
|
1316
1478
|
const liveSuccessors: LiveSuccessor[] = [];
|
|
1317
|
-
const
|
|
1318
|
-
|
|
1319
|
-
|
|
1320
|
-
|
|
1321
|
-
(
|
|
1322
|
-
|
|
1323
|
-
|
|
1324
|
-
|
|
1325
|
-
|
|
1326
|
-
}
|
|
1327
|
-
return outcome.result !== undefined;
|
|
1328
|
-
},
|
|
1329
|
-
spec.scope,
|
|
1330
|
-
);
|
|
1479
|
+
const source = stateWriter && getGraphState(state, depths[index]);
|
|
1480
|
+
const successorCount = forEachActionSuccessor(state, (successor, action) => {
|
|
1481
|
+
try {
|
|
1482
|
+
outcome.result = visitSuccessor(index, successor, liveSuccessors, source, action);
|
|
1483
|
+
} catch (error) {
|
|
1484
|
+
outcome.result = toFailure(error, getTrace(index, successor));
|
|
1485
|
+
}
|
|
1486
|
+
return outcome.result !== undefined;
|
|
1487
|
+
});
|
|
1331
1488
|
current.isExpanding = false;
|
|
1332
1489
|
if (outcome.result) return outcome.result;
|
|
1333
1490
|
if (successorCount === 0 && config.checkDeadlock) {
|
|
@@ -1335,32 +1492,43 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
1335
1492
|
}
|
|
1336
1493
|
try {
|
|
1337
1494
|
const accepted = liveness?.addState(index, state, liveSuccessors);
|
|
1338
|
-
|
|
1339
|
-
|
|
1495
|
+
if (!liveness || !accepted) return undefined;
|
|
1496
|
+
const steps = getPathSteps(accepted);
|
|
1497
|
+
const properties = liveness.getViolatedProperties(
|
|
1498
|
+
steps.map((step) => step.state),
|
|
1499
|
+
steps.length - 1,
|
|
1500
|
+
);
|
|
1340
1501
|
return reportViolation("property-violation", {
|
|
1341
|
-
name:
|
|
1342
|
-
|
|
1502
|
+
name: properties[0],
|
|
1503
|
+
properties,
|
|
1504
|
+
trace: toTrace(steps, accepted),
|
|
1343
1505
|
});
|
|
1344
1506
|
} catch (error) {
|
|
1345
1507
|
return toFailure(error, getStateTrace(index), undefined, getPartialOutDegrees());
|
|
1346
1508
|
}
|
|
1347
1509
|
};
|
|
1348
|
-
|
|
1510
|
+
// TLC names the properties and the step back into the cycle from the states it prints.
|
|
1511
|
+
const reportLasso = (checker: LivenessChecker, lasso: Lasso) => {
|
|
1349
1512
|
const path = [...lasso.prefix, ...lasso.cycle];
|
|
1350
|
-
const
|
|
1351
|
-
const
|
|
1513
|
+
const loopStart = lasso.prefix.length;
|
|
1514
|
+
const steps = getPathSteps(path, loopStart);
|
|
1515
|
+
const trace = toTrace(steps, path, loopStart);
|
|
1516
|
+
const properties = checker.getViolatedProperties(
|
|
1517
|
+
steps.map((step) => step.state),
|
|
1518
|
+
loopStart,
|
|
1519
|
+
);
|
|
1520
|
+
const back = path[loopStart];
|
|
1352
1521
|
const last = path[path.length - 1];
|
|
1522
|
+
const lastState = steps[steps.length - 1].state;
|
|
1353
1523
|
const loopLabel =
|
|
1354
|
-
back === last ? undefined : withoutOutput(() => getLabel(last,
|
|
1524
|
+
back === last ? undefined : withoutOutput(() => getLabel(last, lastState, states[back]));
|
|
1355
1525
|
return reportViolation(
|
|
1356
1526
|
"liveness-violation",
|
|
1357
|
-
{ name:
|
|
1527
|
+
{ name: properties[0], properties, trace, loopStart, loopLabel },
|
|
1358
1528
|
() =>
|
|
1359
1529
|
back === last
|
|
1360
1530
|
? trace[trace.length - 1].action
|
|
1361
|
-
:
|
|
1362
|
-
isSameState(successor.state, states[back]),
|
|
1363
|
-
)?.action,
|
|
1531
|
+
: findSuccessorWithFingerprint(lastState, back)?.action,
|
|
1364
1532
|
);
|
|
1365
1533
|
};
|
|
1366
1534
|
const isPeriodic = liveness !== undefined && options.livenessCheck !== "final";
|
|
@@ -1373,11 +1541,9 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
1373
1541
|
if (!isGrown || periodic.time > (now - startedAt) * LIVENESS_RATIO) return undefined;
|
|
1374
1542
|
periodic.size = expanded;
|
|
1375
1543
|
const lasso = liveness?.findViolation();
|
|
1376
|
-
current.livenessSource = -1;
|
|
1377
1544
|
periodic.time += performance.now() - now;
|
|
1378
1545
|
return lasso;
|
|
1379
1546
|
};
|
|
1380
|
-
setNextStatePhase(true);
|
|
1381
1547
|
for (let index = 0; index < states.length && !runtime.isStopped; index++) {
|
|
1382
1548
|
current.index = index;
|
|
1383
1549
|
current.candidate = undefined;
|
|
@@ -1386,22 +1552,21 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
|
|
|
1386
1552
|
try {
|
|
1387
1553
|
outcome.result = expandState(index);
|
|
1388
1554
|
} catch (error) {
|
|
1389
|
-
outcome.result = toFailure(error, getStateTrace(index));
|
|
1555
|
+
outcome.result = toFailure(withNextStateExitCode(error), getStateTrace(index));
|
|
1390
1556
|
}
|
|
1391
1557
|
if (outcome.result) return outcome.result;
|
|
1392
1558
|
outDegrees[getOutDegreeBucket()]++;
|
|
1393
1559
|
expansion.newStates = 0;
|
|
1394
1560
|
if (isPeriodic && performance.now() >= periodic.at) {
|
|
1395
1561
|
const lasso = findPeriodicViolation(index + 1);
|
|
1396
|
-
if (lasso) return reportLasso(lasso);
|
|
1562
|
+
if (liveness && lasso) return reportLasso(liveness, lasso);
|
|
1397
1563
|
}
|
|
1398
1564
|
}
|
|
1399
1565
|
|
|
1400
1566
|
current.index = -1;
|
|
1401
1567
|
current.candidate = undefined;
|
|
1402
1568
|
const lasso = liveness?.findViolation();
|
|
1403
|
-
|
|
1404
|
-
if (lasso) return reportLasso(lasso);
|
|
1569
|
+
if (liveness && lasso) return reportLasso(liveness, lasso);
|
|
1405
1570
|
|
|
1406
1571
|
const postconditionViolation = search.findPostconditionViolation();
|
|
1407
1572
|
if (postconditionViolation) {
|