Execution Chart

We display below the execution chart for this examination (boot time has been removed).

Trace from the execution

Formatting '/data/fkordon/mcc2023-input.r481-tall-167912692500798.qcow2', fmt=qcow2 size=4294967296 backing_file=/data/fkordon/mcc2023-input.qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16
Waiting for the VM to be ready (probing ssh)
...............
=====================================================================
Generated by BenchKit 2-5348
Executing tool marcie
Input is TwoPhaseLocking-PT-nC00010vN, examination is ReachabilityCardinality
Time confinement is 3600 seconds
Memory confinement is 16384 MBytes
Number of cores is 1
Run identifier is r481-tall-167912692500798
=====================================================================

--------------------
preparation of the directory to be used:
/home/mcc/execution
total 408K
-rw-r--r-- 1 mcc users 6.4K Feb 25 17:53 CTLCardinality.txt
-rw-r--r-- 1 mcc users 60K Feb 25 17:53 CTLCardinality.xml
-rw-r--r-- 1 mcc users 6.0K Feb 25 17:53 CTLFireability.txt
-rw-r--r-- 1 mcc users 52K Feb 25 17:53 CTLFireability.xml
-rw-r--r-- 1 mcc users 4.0K Feb 25 17:22 LTLCardinality.txt
-rw-r--r-- 1 mcc users 26K Feb 25 17:22 LTLCardinality.xml
-rw-r--r-- 1 mcc users 2.3K Feb 25 17:22 LTLFireability.txt
-rw-r--r-- 1 mcc users 15K Feb 25 17:22 LTLFireability.xml
-rw-r--r-- 1 mcc users 12K Feb 25 17:54 ReachabilityCardinality.txt
-rw-r--r-- 1 mcc users 113K Feb 25 17:54 ReachabilityCardinality.xml
-rw-r--r-- 1 mcc users 7.7K Feb 25 17:53 ReachabilityFireability.txt
-rw-r--r-- 1 mcc users 61K Feb 25 17:53 ReachabilityFireability.xml
-rw-r--r-- 1 mcc users 1.8K Feb 25 17:22 UpperBounds.txt
-rw-r--r-- 1 mcc users 3.9K Feb 25 17:22 UpperBounds.xml
-rw-r--r-- 1 mcc users 6 Mar 5 18:23 equiv_col
-rw-r--r-- 1 mcc users 10 Mar 5 18:23 instance
-rw-r--r-- 1 mcc users 6 Mar 5 18:23 iscolored
-rw-r--r-- 1 mcc users 4.6K Mar 5 18:23 model.pnml

--------------------
content from stdout:

=== Data for post analysis generated by BenchKit (invocation template)

The expected result is a vector of booleans
BOOL_VECTOR

here is the order used to build the result vector(from text file)
FORMULA_NAME TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-00
FORMULA_NAME TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-01
FORMULA_NAME TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-02
FORMULA_NAME TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-03
FORMULA_NAME TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-04
FORMULA_NAME TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-05
FORMULA_NAME TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-06
FORMULA_NAME TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-07
FORMULA_NAME TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-08
FORMULA_NAME TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-09
FORMULA_NAME TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-10
FORMULA_NAME TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-11
FORMULA_NAME TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-12
FORMULA_NAME TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-13
FORMULA_NAME TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-14
FORMULA_NAME TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-15

=== Now, execution of the tool begins

BK_START 1679868287613

bash -c /home/mcc/BenchKit/BenchKit_head.sh 2> STDERR ; echo ; echo -n "BK_STOP " ; date -u +%s%3N
Invoking MCC driver with
BK_TOOL=marcie
BK_EXAMINATION=ReachabilityCardinality
BK_BIN_PATH=/home/mcc/BenchKit/bin/
BK_TIME_CONFINEMENT=3600
BK_INPUT=TwoPhaseLocking-PT-nC00010vN
Not applying reductions.
Model is PT
ReachabilityCardinality PT
timeout --kill-after=10s --signal=SIGINT 1m for testing only

Marcie built on Linux at 2019-11-18.
A model checker for Generalized Stochastic Petri nets

authors: Alex Tovchigrechko (IDD package and CTL model checking)

Martin Schwarick (Symbolic numerical analysis and CSL model checking)

Christian Rohr (Simulative and approximative numerical model checking)

marcie@informatik.tu-cottbus.de

called as: /home/mcc/BenchKit/bin//../marcie/bin/marcie --net-file=model.pnml --mcc-file=ReachabilityCardinality.xml --memory=6 --mcc-mode

parse successfull
net created successfully

Net: TwoPhaseLocking_PT_nC00010vN
(NrP: 8 NrTr: 6 NrArc: 18)

parse formulas
formulas created successfully
place and transition orderings generation:0m 0.000sec

net check time: 0m 0.000sec

init dd package: 0m 2.839sec


RS generation: 0m 0.001sec


-> reachability set: #nodes 285 (2.8e+02) #states 624



starting MCC model checker
--------------------------

checking: AG [haveAandB<=2]
normalized: ~ [E [true U ~ [haveAandB<=2]]]

abstracting: (haveAandB<=2)
states: 576
-> the formula is FALSE

FORMULA TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-01 FALSE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.002sec

checking: AG [resB<=10]
normalized: ~ [E [true U ~ [resB<=10]]]

abstracting: (resB<=10)
states: 624
-> the formula is TRUE

FORMULA TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-09 TRUE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.000sec

checking: AG [3<=resB]
normalized: ~ [E [true U ~ [3<=resB]]]

abstracting: (3<=resB)
states: 258
-> the formula is FALSE

FORMULA TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-14 FALSE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.000sec

checking: EF [~ [[2<=haveA | 4<=haveA2]]]
normalized: E [true U ~ [[2<=haveA | 4<=haveA2]]]

abstracting: (4<=haveA2)
states: 31
abstracting: (2<=haveA)
states: 199
-> the formula is TRUE

FORMULA TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-00 TRUE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.001sec

checking: EF [[~ [haveA2andB<=6] | 4<=haveB]]
normalized: E [true U [~ [haveA2andB<=6] | 4<=haveB]]

abstracting: (4<=haveB)
states: 147
abstracting: (haveA2andB<=6)
states: 624
-> the formula is TRUE

FORMULA TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-07 TRUE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.000sec

checking: EF [~ [resA<=resB]]
normalized: E [true U ~ [resA<=resB]]

abstracting: (resA<=resB)
states: 498
-> the formula is TRUE

FORMULA TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-13 TRUE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.001sec

checking: AG [[haveA2andB<=haveB | [~ [haveB<=resB] | Clients<=5]]]
normalized: ~ [E [true U ~ [[[~ [haveB<=resB] | Clients<=5] | haveA2andB<=haveB]]]]

abstracting: (haveA2andB<=haveB)
states: 507
abstracting: (Clients<=5)
states: 498
abstracting: (haveB<=resB)
states: 348
-> the formula is FALSE

FORMULA TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-11 FALSE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.001sec

checking: AG [[haveA2<=resB | ~ [[[~ [haveA2andB<=haveA2] & Clients<=haveAandB] | haveB<=3]]]]
normalized: ~ [E [true U ~ [[~ [[[~ [haveA2andB<=haveA2] & Clients<=haveAandB] | haveB<=3]] | haveA2<=resB]]]]

abstracting: (haveA2<=resB)
states: 503
abstracting: (haveB<=3)
states: 477
abstracting: (Clients<=haveAandB)
states: 66
abstracting: (haveA2andB<=haveA2)
states: 440
-> the formula is FALSE

FORMULA TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-12 FALSE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.001sec

checking: EF [[[9<=haveB & haveB<=haveB] | [~ [[haveA2<=haveB | resA<=haveA2]] | [haveA2<=Clients | [[[~ [[~ [6<=resA] & ~ [4<=haveA]]] | 5<=haveA2andB] | [[[haveA2andB<=0 | 4<=haveA2andB] & [haveA<=10 | resB<=8]] & haveA2andB<=haveA2andB]] & Clients<=2]]]]]
normalized: E [true U [[[[[[[[haveA<=10 | resB<=8] & [haveA2andB<=0 | 4<=haveA2andB]] & haveA2andB<=haveA2andB] | [~ [[~ [4<=haveA] & ~ [6<=resA]]] | 5<=haveA2andB]] & Clients<=2] | haveA2<=Clients] | ~ [[haveA2<=haveB | resA<=haveA2]]] | [9<=haveB & haveB<=haveB]]]

abstracting: (haveB<=haveB)
states: 624
abstracting: (9<=haveB)
states: 0
abstracting: (resA<=haveA2)
states: 382
abstracting: (haveA2<=haveB)
states: 498
abstracting: (haveA2<=Clients)
states: 561
abstracting: (Clients<=2)
states: 141
abstracting: (5<=haveA2andB)
states: 2
abstracting: (6<=resA)
states: 0
abstracting: (4<=haveA)
states: 31
abstracting: (haveA2andB<=haveA2andB)
states: 624
abstracting: (4<=haveA2andB)
states: 13
abstracting: (haveA2andB<=0)
states: 316
abstracting: (resB<=8)
states: 624
abstracting: (haveA<=10)
states: 624
-> the formula is TRUE

FORMULA TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-05 TRUE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.001sec

checking: AG [[[4<=resA | 1<=Clients] | [[~ [[~ [haveAandB<=haveA] & haveAandB<=haveA2andB]] & [~ [[resB<=resA | [~ [[haveA2<=haveA2andB | haveA<=haveA]] & [[haveB<=Clients & haveA<=haveA2andB] & ~ [haveA2andB<=haveA2]]]]] | ~ [1<=Clients]]] & 1<=resB]]]
normalized: ~ [E [true U ~ [[[[[~ [1<=Clients] | ~ [[[[~ [haveA2andB<=haveA2] & [haveB<=Clients & haveA<=haveA2andB]] & ~ [[haveA2<=haveA2andB | haveA<=haveA]]] | resB<=resA]]] & ~ [[haveAandB<=haveA2andB & ~ [haveAandB<=haveA]]]] & 1<=resB] | [4<=resA | 1<=Clients]]]]]

abstracting: (1<=Clients)
states: 603
abstracting: (4<=resA)
states: 33
abstracting: (1<=resB)
states: 504
abstracting: (haveAandB<=haveA)
states: 440
abstracting: (haveAandB<=haveA2andB)
states: 412
abstracting: (resB<=resA)
states: 246
abstracting: (haveA<=haveA)
states: 624
abstracting: (haveA2<=haveA2andB)
states: 359
abstracting: (haveA<=haveA2andB)
states: 359
abstracting: (haveB<=Clients)
states: 453
abstracting: (haveA2andB<=haveA2)
states: 440
abstracting: (1<=Clients)
states: 603
-> the formula is FALSE

FORMULA TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-02 FALSE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.002sec

checking: EF [[[~ [[~ [8<=haveAandB] & [[[[[haveAandB<=haveA2 & resA<=10] & ~ [haveAandB<=1]] & haveB<=4] & resA<=3] & ~ [haveA2<=resA]]]] & ~ [[[~ [haveB<=Clients] | [haveA<=7 & [[10<=haveA2 & Clients<=haveB] | ~ [haveA2andB<=haveAandB]]]] & [[[[haveA2<=resB | haveB<=5] | [6<=haveA & haveB<=resB]] | haveAandB<=4] & 10<=haveAandB]]]] & Clients<=4]]
normalized: E [true U [[~ [[[[[[6<=haveA & haveB<=resB] | [haveA2<=resB | haveB<=5]] | haveAandB<=4] & 10<=haveAandB] & [[[~ [haveA2andB<=haveAandB] | [10<=haveA2 & Clients<=haveB]] & haveA<=7] | ~ [haveB<=Clients]]]] & ~ [[[~ [haveA2<=resA] & [[[~ [haveAandB<=1] & [haveAandB<=haveA2 & resA<=10]] & haveB<=4] & resA<=3]] & ~ [8<=haveAandB]]]] & Clients<=4]]

abstracting: (Clients<=4)
states: 372
abstracting: (8<=haveAandB)
states: 0
abstracting: (resA<=3)
states: 591
abstracting: (haveB<=4)
states: 558
abstracting: (resA<=10)
states: 624
abstracting: (haveAandB<=haveA2)
states: 440
abstracting: (haveAandB<=1)
states: 491
abstracting: (haveA2<=resA)
states: 387
abstracting: (haveB<=Clients)
states: 453
abstracting: (haveA<=7)
states: 624
abstracting: (Clients<=haveB)
states: 212
abstracting: (10<=haveA2)
states: 0
abstracting: (haveA2andB<=haveAandB)
states: 412
abstracting: (10<=haveAandB)
states: 0
abstracting: (haveAandB<=4)
states: 622
abstracting: (haveB<=5)
states: 609
abstracting: (haveA2<=resB)
states: 503
abstracting: (haveB<=resB)
states: 348
abstracting: (6<=haveA)
states: 0
-> the formula is TRUE

FORMULA TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-10 TRUE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.002sec

checking: AG [[~ [[[[~ [5<=haveA2] & [resA<=haveB & [[Clients<=haveA | haveA2<=haveA2] | [haveB<=Clients | resA<=4]]]] & [[[[haveA2<=resA & haveB<=haveA] & [haveA2andB<=resB & resB<=0]] | [7<=haveA2 | [haveAandB<=haveA2andB | haveAandB<=haveAandB]]] & haveA2<=0]] & [haveAandB<=10 | [[[9<=haveA2andB & [resA<=2 | Clients<=8]] & ~ [[Clients<=5 | haveA<=resA]]] & [Clients<=9 | resB<=haveA]]]]] | resB<=0]]
normalized: ~ [E [true U ~ [[~ [[[[[Clients<=9 | resB<=haveA] & [~ [[Clients<=5 | haveA<=resA]] & [[resA<=2 | Clients<=8] & 9<=haveA2andB]]] | haveAandB<=10] & [[[[[haveAandB<=haveA2andB | haveAandB<=haveAandB] | 7<=haveA2] | [[haveA2andB<=resB & resB<=0] & [haveA2<=resA & haveB<=haveA]]] & haveA2<=0] & [[[[haveB<=Clients | resA<=4] | [Clients<=haveA | haveA2<=haveA2]] & resA<=haveB] & ~ [5<=haveA2]]]]] | resB<=0]]]]

abstracting: (resB<=0)
states: 120
abstracting: (5<=haveA2)
states: 6
abstracting: (resA<=haveB)
states: 498
abstracting: (haveA2<=haveA2)
states: 624
abstracting: (Clients<=haveA)
states: 112
abstracting: (resA<=4)
states: 617
abstracting: (haveB<=Clients)
states: 453
abstracting: (haveA2<=0)
states: 251
abstracting: (haveB<=haveA)
states: 252
abstracting: (haveA2<=resA)
states: 387
abstracting: (resB<=0)
states: 120
abstracting: (haveA2andB<=resB)
states: 507
abstracting: (7<=haveA2)
states: 0
abstracting: (haveAandB<=haveAandB)
states: 624
abstracting: (haveAandB<=haveA2andB)
states: 412
abstracting: (haveAandB<=10)
states: 624
abstracting: (9<=haveA2andB)
states: 0
abstracting: (Clients<=8)
states: 618
abstracting: (resA<=2)
states: 531
abstracting: (haveA<=resA)
states: 387
abstracting: (Clients<=5)
states: 498
abstracting: (resB<=haveA)
states: 246
abstracting: (Clients<=9)
states: 623
-> the formula is FALSE

FORMULA TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-15 FALSE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.003sec

checking: AG [[[haveAandB<=haveAandB | [haveAandB<=2 | [~ [[[Clients<=resA | [resA<=10 | haveB<=resB]] | 8<=haveA]] | [~ [[haveA2andB<=3 | [haveA<=7 & [haveA<=Clients & 2<=Clients]]]] & [[[~ [4<=haveB] & [haveA2andB<=4 | haveA2<=haveA2]] | [~ [haveA<=2] & [haveA<=haveA & resB<=9]]] & haveA<=6]]]]] & [[[~ [[~ [haveA2andB<=7] | ~ [[haveAandB<=resA | 10<=haveA2]]]] | ~ [[[haveA2<=0 | ~ [resA<=7]] | resB<=haveA2]]] | [haveAandB<=resA & ~ [3<=haveA]]] | haveAandB<=haveB]]]
normalized: ~ [E [true U ~ [[[[[~ [3<=haveA] & haveAandB<=resA] | [~ [[[~ [resA<=7] | haveA2<=0] | resB<=haveA2]] | ~ [[~ [[haveAandB<=resA | 10<=haveA2]] | ~ [haveA2andB<=7]]]]] | haveAandB<=haveB] & [[[[[[[[haveA<=haveA & resB<=9] & ~ [haveA<=2]] | [[haveA2andB<=4 | haveA2<=haveA2] & ~ [4<=haveB]]] & haveA<=6] & ~ [[[[haveA<=Clients & 2<=Clients] & haveA<=7] | haveA2andB<=3]]] | ~ [[[[resA<=10 | haveB<=resB] | Clients<=resA] | 8<=haveA]]] | haveAandB<=2] | haveAandB<=haveAandB]]]]]

abstracting: (haveAandB<=haveAandB)
states: 624
abstracting: (haveAandB<=2)
states: 576
abstracting: (8<=haveA)
states: 0
abstracting: (Clients<=resA)
states: 66
abstracting: (haveB<=resB)
states: 348
abstracting: (resA<=10)
states: 624
abstracting: (haveA2andB<=3)
states: 611
abstracting: (haveA<=7)
states: 624
abstracting: (2<=Clients)
states: 558
abstracting: (haveA<=Clients)
states: 561
abstracting: (haveA<=6)
states: 624
abstracting: (4<=haveB)
states: 147
abstracting: (haveA2<=haveA2)
states: 624
abstracting: (haveA2andB<=4)
states: 622
abstracting: (haveA<=2)
states: 534
abstracting: (resB<=9)
states: 624
abstracting: (haveA<=haveA)
states: 624
abstracting: (haveAandB<=haveB)
states: 507
abstracting: (haveA2andB<=7)
states: 624
abstracting: (10<=haveA2)
states: 0
abstracting: (haveAandB<=resA)
states: 440
abstracting: (resB<=haveA2)
states: 246
abstracting: (haveA2<=0)
states: 251
abstracting: (resA<=7)
states: 624
abstracting: (haveAandB<=resA)
states: 440
abstracting: (3<=haveA)
states: 90
-> the formula is FALSE

FORMULA TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-08 FALSE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.003sec

checking: AG [[[[[~ [6<=haveA2] | 4<=haveA2andB] & [resA<=9 | [[[[[haveB<=haveB | haveA2andB<=haveA2andB] & 4<=haveAandB] | [10<=haveA2 & ~ [haveA2andB<=6]]] & [[[resB<=haveA2andB | 1<=resA] | [Clients<=6 | resB<=0]] | ~ [[resA<=0 & haveA2<=Clients]]]] | ~ [[7<=haveAandB & [[2<=haveA2 & haveA2andB<=7] & [Clients<=haveA2 | haveA<=haveB]]]]]]] & [5<=Clients | [[[[~ [[9<=haveA2 | Clients<=8]] & [[10<=haveA & 5<=Clients] & haveA2<=haveA2andB]] & ~ [resA<=haveA]] | [[~ [Clients<=9] & [~ [5<=resB] | [7<=resA & 1<=resA]]] & ~ [4<=Clients]]] & resB<=haveA2andB]]] | 9<=resB]]
normalized: ~ [E [true U ~ [[[[[[[~ [4<=Clients] & [[[7<=resA & 1<=resA] | ~ [5<=resB]] & ~ [Clients<=9]]] | [~ [resA<=haveA] & [[[10<=haveA & 5<=Clients] & haveA2<=haveA2andB] & ~ [[9<=haveA2 | Clients<=8]]]]] & resB<=haveA2andB] | 5<=Clients] & [[[~ [[[[Clients<=haveA2 | haveA<=haveB] & [2<=haveA2 & haveA2andB<=7]] & 7<=haveAandB]] | [[~ [[resA<=0 & haveA2<=Clients]] | [[Clients<=6 | resB<=0] | [resB<=haveA2andB | 1<=resA]]] & [[~ [haveA2andB<=6] & 10<=haveA2] | [[haveB<=haveB | haveA2andB<=haveA2andB] & 4<=haveAandB]]]] | resA<=9] & [~ [6<=haveA2] | 4<=haveA2andB]]] | 9<=resB]]]]

abstracting: (9<=resB)
states: 0
abstracting: (4<=haveA2andB)
states: 13
abstracting: (6<=haveA2)
states: 0
abstracting: (resA<=9)
states: 624
abstracting: (4<=haveAandB)
states: 13
abstracting: (haveA2andB<=haveA2andB)
states: 624
abstracting: (haveB<=haveB)
states: 624
abstracting: (10<=haveA2)
states: 0
abstracting: (haveA2andB<=6)
states: 624
abstracting: (1<=resA)
states: 378
abstracting: (resB<=haveA2andB)
states: 227
abstracting: (resB<=0)
states: 120
abstracting: (Clients<=6)
states: 568
abstracting: (haveA2<=Clients)
states: 561
abstracting: (resA<=0)
states: 246
abstracting: (7<=haveAandB)
states: 0
abstracting: (haveA2andB<=7)
states: 624
abstracting: (2<=haveA2)
states: 199
abstracting: (haveA<=haveB)
states: 498
abstracting: (Clients<=haveA2)
states: 112
abstracting: (5<=Clients)
states: 252
abstracting: (resB<=haveA2andB)
states: 227
abstracting: (Clients<=8)
states: 618
abstracting: (9<=haveA2)
states: 0
abstracting: (haveA2<=haveA2andB)
states: 359
abstracting: (5<=Clients)
states: 252
abstracting: (10<=haveA)
states: 0
abstracting: (resA<=haveA)
states: 382
abstracting: (Clients<=9)
states: 623
abstracting: (5<=resB)
states: 72
abstracting: (1<=resA)
states: 378
abstracting: (7<=resA)
states: 0
abstracting: (4<=Clients)
states: 378
-> the formula is FALSE

FORMULA TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-04 FALSE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.002sec

checking: EF [~ [[[[~ [haveAandB<=9] | [2<=resB | [haveA2<=5 & [[haveA<=10 & [Clients<=2 & resA<=haveA2andB]] & [[haveA<=5 | 7<=resA] & [1<=resB | haveA2<=haveAandB]]]]]] | [[~ [resB<=resB] & haveA<=2] | [[~ [[2<=haveA2andB & [resB<=7 | haveAandB<=6]]] & ~ [resA<=5]] & [[~ [haveA2<=haveB] | [~ [resB<=haveA2andB] & [Clients<=resA & 5<=resA]]] | [~ [[resB<=8 | 10<=haveA2andB]] & ~ [resB<=haveA2andB]]]]]] | ~ [[[haveA<=resB & [~ [haveA2<=0] & [[[haveB<=haveA & Clients<=Clients] | ~ [resB<=9]] & [haveAandB<=9 & ~ [haveAandB<=3]]]]] | ~ [[~ [[~ [5<=resA] | ~ [haveA2<=Clients]]] & haveA2<=Clients]]]]]]]
normalized: E [true U ~ [[~ [[~ [[~ [[~ [haveA2<=Clients] | ~ [5<=resA]]] & haveA2<=Clients]] | [[[[~ [haveAandB<=3] & haveAandB<=9] & [~ [resB<=9] | [haveB<=haveA & Clients<=Clients]]] & ~ [haveA2<=0]] & haveA<=resB]]] | [[[[[~ [resB<=haveA2andB] & ~ [[resB<=8 | 10<=haveA2andB]]] | [[[Clients<=resA & 5<=resA] & ~ [resB<=haveA2andB]] | ~ [haveA2<=haveB]]] & [~ [resA<=5] & ~ [[[resB<=7 | haveAandB<=6] & 2<=haveA2andB]]]] | [~ [resB<=resB] & haveA<=2]] | [[[[[[1<=resB | haveA2<=haveAandB] & [haveA<=5 | 7<=resA]] & [[Clients<=2 & resA<=haveA2andB] & haveA<=10]] & haveA2<=5] | 2<=resB] | ~ [haveAandB<=9]]]]]]

abstracting: (haveAandB<=9)
states: 624
abstracting: (2<=resB)
states: 378
abstracting: (haveA2<=5)
states: 624
abstracting: (haveA<=10)
states: 624
abstracting: (resA<=haveA2andB)
states: 354
abstracting: (Clients<=2)
states: 141
abstracting: (7<=resA)
states: 0
abstracting: (haveA<=5)
states: 624
abstracting: (haveA2<=haveAandB)
states: 359
abstracting: (1<=resB)
states: 504
abstracting: (haveA<=2)
states: 534
abstracting: (resB<=resB)
states: 624
abstracting: (2<=haveA2andB)
states: 133
abstracting: (haveAandB<=6)
states: 624
abstracting: (resB<=7)
states: 624
abstracting: (resA<=5)
states: 624
abstracting: (haveA2<=haveB)
states: 498
abstracting: (resB<=haveA2andB)
states: 227
abstracting: (5<=resA)
states: 7
abstracting: (Clients<=resA)
states: 66
abstracting: (10<=haveA2andB)
states: 0
abstracting: (resB<=8)
states: 624
abstracting: (resB<=haveA2andB)
states: 227
abstracting: (haveA<=resB)
states: 503
abstracting: (haveA2<=0)
states: 251
abstracting: (Clients<=Clients)
states: 624
abstracting: (haveB<=haveA)
states: 252
abstracting: (resB<=9)
states: 624
abstracting: (haveAandB<=9)
states: 624
abstracting: (haveAandB<=3)
states: 611
abstracting: (haveA2<=Clients)
states: 561
abstracting: (5<=resA)
states: 7
abstracting: (haveA2<=Clients)
states: 561
-> the formula is TRUE

FORMULA TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-03 TRUE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.002sec

checking: AG [[[[[haveA2andB<=haveA2andB & 2<=resA] & 9<=resA] | [9<=haveA2andB & ~ [[[4<=haveA2andB | ~ [haveA2<=resB]] & ~ [Clients<=9]]]]] | [[~ [[[[haveAandB<=7 & ~ [[haveA2andB<=haveA | 10<=haveA2]]] | [2<=haveB | ~ [Clients<=8]]] & [4<=Clients | [[[haveB<=haveA2andB | haveAandB<=8] & [haveA<=1 & haveA2andB<=5]] | [~ [3<=resB] | [4<=haveA2andB | haveA<=0]]]]]] | ~ [3<=resB]] & [[[~ [haveB<=5] & [haveAandB<=resA & Clients<=9]] & [~ [[[Clients<=7 & Clients<=3] & [haveA2<=0 | resA<=haveB]]] | [[haveAandB<=haveA2 | 2<=haveA2] | [haveA2andB<=10 & ~ [haveB<=2]]]]] | [[[~ [resA<=10] | 8<=haveAandB] & [[~ [[3<=haveB & resA<=resB]] | ~ [[haveA<=1 & 1<=Clients]]] | [[[resB<=haveA2 | resA<=4] | Clients<=Clients] | [[4<=haveB & haveA2<=haveAandB] | haveA<=5]]]] & ~ [[~ [[[haveA<=7 | 7<=resA] | [haveA2<=0 & resA<=haveA2]]] & ~ [8<=resB]]]]]]]]
normalized: ~ [E [true U ~ [[[[[~ [[~ [8<=resB] & ~ [[[haveA2<=0 & resA<=haveA2] | [haveA<=7 | 7<=resA]]]]] & [[[[[4<=haveB & haveA2<=haveAandB] | haveA<=5] | [[resB<=haveA2 | resA<=4] | Clients<=Clients]] | [~ [[haveA<=1 & 1<=Clients]] | ~ [[3<=haveB & resA<=resB]]]] & [~ [resA<=10] | 8<=haveAandB]]] | [[[[~ [haveB<=2] & haveA2andB<=10] | [haveAandB<=haveA2 | 2<=haveA2]] | ~ [[[haveA2<=0 | resA<=haveB] & [Clients<=7 & Clients<=3]]]] & [[haveAandB<=resA & Clients<=9] & ~ [haveB<=5]]]] & [~ [3<=resB] | ~ [[[[[[4<=haveA2andB | haveA<=0] | ~ [3<=resB]] | [[haveA<=1 & haveA2andB<=5] & [haveB<=haveA2andB | haveAandB<=8]]] | 4<=Clients] & [[~ [Clients<=8] | 2<=haveB] | [~ [[haveA2andB<=haveA | 10<=haveA2]] & haveAandB<=7]]]]]] | [[~ [[~ [Clients<=9] & [~ [haveA2<=resB] | 4<=haveA2andB]]] & 9<=haveA2andB] | [[haveA2andB<=haveA2andB & 2<=resA] & 9<=resA]]]]]]

abstracting: (9<=resA)
states: 0
abstracting: (2<=resA)
states: 203
abstracting: (haveA2andB<=haveA2andB)
states: 624
abstracting: (9<=haveA2andB)
states: 0
abstracting: (4<=haveA2andB)
states: 13
abstracting: (haveA2<=resB)
states: 503
abstracting: (Clients<=9)
states: 623
abstracting: (haveAandB<=7)
states: 624
abstracting: (10<=haveA2)
states: 0
abstracting: (haveA2andB<=haveA)
states: 440
abstracting: (2<=haveB)
states: 372
abstracting: (Clients<=8)
states: 618
abstracting: (4<=Clients)
states: 378
abstracting: (haveAandB<=8)
states: 624
abstracting: (haveB<=haveA2andB)
states: 233
abstracting: (haveA2andB<=5)
states: 624
abstracting: (haveA<=1)
states: 425
abstracting: (3<=resB)
states: 258
abstracting: (haveA<=0)
states: 251
abstracting: (4<=haveA2andB)
states: 13
abstracting: (3<=resB)
states: 258
abstracting: (haveB<=5)
states: 609
abstracting: (Clients<=9)
states: 623
abstracting: (haveAandB<=resA)
states: 440
abstracting: (Clients<=3)
states: 246
abstracting: (Clients<=7)
states: 603
abstracting: (resA<=haveB)
states: 498
abstracting: (haveA2<=0)
states: 251
abstracting: (2<=haveA2)
states: 199
abstracting: (haveAandB<=haveA2)
states: 440
abstracting: (haveA2andB<=10)
states: 624
abstracting: (haveB<=2)
states: 372
abstracting: (8<=haveAandB)
states: 0
abstracting: (resA<=10)
states: 624
abstracting: (resA<=resB)
states: 498
abstracting: (3<=haveB)
states: 252
abstracting: (1<=Clients)
states: 603
abstracting: (haveA<=1)
states: 425
abstracting: (Clients<=Clients)
states: 624
abstracting: (resA<=4)
states: 617
abstracting: (resB<=haveA2)
states: 246
abstracting: (haveA<=5)
states: 624
abstracting: (haveA2<=haveAandB)
states: 359
abstracting: (4<=haveB)
states: 147
abstracting: (7<=resA)
states: 0
abstracting: (haveA<=7)
states: 624
abstracting: (resA<=haveA2)
states: 382
abstracting: (haveA2<=0)
states: 251
abstracting: (8<=resB)
states: 0
-> the formula is FALSE

FORMULA TwoPhaseLocking-PT-nC00010vN-ReachabilityCardinality-06 FALSE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.002sec

totally nodes used: 5991 (6.0e+03)
number of garbage collections: 0
fire ops cache: hits/miss/sum: 16967 9315 26282
used/not used/entry size/cache size: 11693 67097171 16 1024MB
basic ops cache: hits/miss/sum: 22984 29951 52935
used/not used/entry size/cache size: 41406 16735810 12 192MB
unary ops cache: hits/miss/sum: 0 0 0
used/not used/entry size/cache size: 0 16777216 8 128MB
abstract ops cache: hits/miss/sum: 0 0 0
used/not used/entry size/cache size: 0 16777216 12 192MB
state nr cache: hits/miss/sum: 4792 2465 7257
used/not used/entry size/cache size: 2465 8386143 32 256MB
max state cache: hits/miss/sum: 0 0 0
used/not used/entry size/cache size: 0 8388608 32 256MB
uniqueHash elements/entry size/size: 67108864 4 256MB
0 67103470
1 5174
2 151
3 21
4 9
5 3
6 4
7 4
8 1
9 7
>= 10 20

Total processing time: 0m 4.544sec


BK_STOP 1679868292208

--------------------
content from stderr:

check for maximal unmarked siphon
ok
check for constant places
ok
check if there are places and transitions
ok
check if there are transitions without pre-places
ok
check if at least one transition is enabled in m0
ok
check if there are transitions that can never fire
ok


initing FirstDep: 0m 0.000sec


iterations count:131 (21), effective:40 (6)

initing FirstDep: 0m 0.000sec


iterations count:72 (12), effective:23 (3)

iterations count:26 (4), effective:12 (2)

iterations count:67 (11), effective:21 (3)

iterations count:62 (10), effective:20 (3)

iterations count:52 (8), effective:20 (3)

iterations count:135 (22), effective:39 (6)

iterations count:97 (16), effective:33 (5)

iterations count:12 (2), effective:3 (0)

iterations count:89 (14), effective:32 (5)

iterations count:35 (5), effective:13 (2)

iterations count:42 (7), effective:14 (2)

iterations count:96 (16), effective:32 (5)

iterations count:30 (5), effective:10 (1)

iterations count:45 (7), effective:19 (3)

iterations count:11 (1), effective:1 (0)

Sequence of Actions to be Executed by the VM

This is useful if one wants to reexecute the tool in the VM from the submitted image disk.

set -x
# this is for BenchKit: configuration of major elements for the test
export BK_INPUT="TwoPhaseLocking-PT-nC00010vN"
export BK_EXAMINATION="ReachabilityCardinality"
export BK_TOOL="marcie"
export BK_RESULT_DIR="/tmp/BK_RESULTS/OUTPUTS"
export BK_TIME_CONFINEMENT="3600"
export BK_MEMORY_CONFINEMENT="16384"
export BK_BIN_PATH="/home/mcc/BenchKit/bin/"

# this is specific to your benchmark or test

export BIN_DIR="$HOME/BenchKit/bin"

# remove the execution directoty if it exists (to avoid increse of .vmdk images)
if [ -d execution ] ; then
rm -rf execution
fi

# this is for BenchKit: explicit launching of the test
echo "====================================================================="
echo " Generated by BenchKit 2-5348"
echo " Executing tool marcie"
echo " Input is TwoPhaseLocking-PT-nC00010vN, examination is ReachabilityCardinality"
echo " Time confinement is $BK_TIME_CONFINEMENT seconds"
echo " Memory confinement is 16384 MBytes"
echo " Number of cores is 1"
echo " Run identifier is r481-tall-167912692500798"
echo "====================================================================="
echo
echo "--------------------"
echo "preparation of the directory to be used:"

tar xzf /home/mcc/BenchKit/INPUTS/TwoPhaseLocking-PT-nC00010vN.tgz
mv TwoPhaseLocking-PT-nC00010vN execution
cd execution
if [ "ReachabilityCardinality" = "ReachabilityDeadlock" ] || [ "ReachabilityCardinality" = "UpperBounds" ] || [ "ReachabilityCardinality" = "QuasiLiveness" ] || [ "ReachabilityCardinality" = "StableMarking" ] || [ "ReachabilityCardinality" = "Liveness" ] || [ "ReachabilityCardinality" = "OneSafe" ] || [ "ReachabilityCardinality" = "StateSpace" ]; then
rm -f GenericPropertiesVerdict.xml
fi
pwd
ls -lh

echo
echo "--------------------"
echo "content from stdout:"
echo
echo "=== Data for post analysis generated by BenchKit (invocation template)"
echo
if [ "ReachabilityCardinality" = "UpperBounds" ] ; then
echo "The expected result is a vector of positive values"
echo NUM_VECTOR
elif [ "ReachabilityCardinality" != "StateSpace" ] ; then
echo "The expected result is a vector of booleans"
echo BOOL_VECTOR
else
echo "no data necessary for post analysis"
fi
echo
if [ -f "ReachabilityCardinality.txt" ] ; then
echo "here is the order used to build the result vector(from text file)"
for x in $(grep Property ReachabilityCardinality.txt | cut -d ' ' -f 2 | sort -u) ; do
echo "FORMULA_NAME $x"
done
elif [ -f "ReachabilityCardinality.xml" ] ; then # for cunf (txt files deleted;-)
echo echo "here is the order used to build the result vector(from xml file)"
for x in $(grep '' ReachabilityCardinality.xml | cut -d '>' -f 2 | cut -d '<' -f 1 | sort -u) ; do
echo "FORMULA_NAME $x"
done
elif [ "ReachabilityCardinality" = "ReachabilityDeadlock" ] || [ "ReachabilityCardinality" = "QuasiLiveness" ] || [ "ReachabilityCardinality" = "StableMarking" ] || [ "ReachabilityCardinality" = "Liveness" ] || [ "ReachabilityCardinality" = "OneSafe" ] ; then
echo "FORMULA_NAME ReachabilityCardinality"
fi
echo
echo "=== Now, execution of the tool begins"
echo
echo -n "BK_START "
date -u +%s%3N
echo
timeout -s 9 $BK_TIME_CONFINEMENT bash -c "/home/mcc/BenchKit/BenchKit_head.sh 2> STDERR ; echo ; echo -n \"BK_STOP \" ; date -u +%s%3N"
if [ $? -eq 137 ] ; then
echo
echo "BK_TIME_CONFINEMENT_REACHED"
fi
echo
echo "--------------------"
echo "content from stderr:"
echo
cat STDERR ;