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.r490-tall-167912709200838.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 marciexred
Input is TwoPhaseLocking-PT-nC00100vD, examination is ReachabilityCardinality
Time confinement is 3600 seconds
Memory confinement is 16384 MBytes
Number of cores is 4
Run identifier is r490-tall-167912709200838
=====================================================================

--------------------
preparation of the directory to be used:
/home/mcc/execution
total 456K
-rw-r--r-- 1 mcc users 7.2K Feb 25 17:31 CTLCardinality.txt
-rw-r--r-- 1 mcc users 69K Feb 25 17:31 CTLCardinality.xml
-rw-r--r-- 1 mcc users 6.3K Feb 25 17:30 CTLFireability.txt
-rw-r--r-- 1 mcc users 56K Feb 25 17:30 CTLFireability.xml
-rw-r--r-- 1 mcc users 3.9K Feb 25 17:23 LTLCardinality.txt
-rw-r--r-- 1 mcc users 25K Feb 25 17:23 LTLCardinality.xml
-rw-r--r-- 1 mcc users 2.4K Feb 25 17:23 LTLFireability.txt
-rw-r--r-- 1 mcc users 18K Feb 25 17:23 LTLFireability.xml
-rw-r--r-- 1 mcc users 13K Feb 25 17:32 ReachabilityCardinality.txt
-rw-r--r-- 1 mcc users 131K Feb 25 17:32 ReachabilityCardinality.xml
-rw-r--r-- 1 mcc users 8.2K Feb 25 17:31 ReachabilityFireability.txt
-rw-r--r-- 1 mcc users 67K Feb 25 17:31 ReachabilityFireability.xml
-rw-r--r-- 1 mcc users 1.8K Feb 25 17:23 UpperBounds.txt
-rw-r--r-- 1 mcc users 3.9K Feb 25 17:23 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-nC00100vD-ReachabilityCardinality-00
FORMULA_NAME TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-01
FORMULA_NAME TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-02
FORMULA_NAME TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-03
FORMULA_NAME TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-04
FORMULA_NAME TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-05
FORMULA_NAME TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-06
FORMULA_NAME TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-07
FORMULA_NAME TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-08
FORMULA_NAME TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-09
FORMULA_NAME TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-10
FORMULA_NAME TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-11
FORMULA_NAME TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-12
FORMULA_NAME TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-13
FORMULA_NAME TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-14
FORMULA_NAME TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-15

=== Now, execution of the tool begins

BK_START 1679339501945

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=marciexred
BK_EXAMINATION=ReachabilityCardinality
BK_BIN_PATH=/home/mcc/BenchKit/bin/
BK_TIME_CONFINEMENT=3600
BK_INPUT=TwoPhaseLocking-PT-nC00100vD
Applying reductions before tool marcie
Invoking reducer
Running Version 202303021504
[2023-03-20 19:11:43] [INFO ] Running its-tools with arguments : [-pnfolder, /home/mcc/execution, -examination, ReachabilityCardinality, -timeout, 360, -rebuildPNML]
[2023-03-20 19:11:43] [INFO ] Parsing pnml file : /home/mcc/execution/model.pnml
[2023-03-20 19:11:43] [INFO ] Load time of PNML (sax parser for PT used): 16 ms
[2023-03-20 19:11:43] [INFO ] Transformed 8 places.
[2023-03-20 19:11:43] [INFO ] Transformed 6 transitions.
[2023-03-20 19:11:43] [INFO ] Parsed PT model containing 8 places and 6 transitions and 18 arcs in 71 ms.
Parsed 16 properties from file /home/mcc/execution/ReachabilityCardinality.xml in 18 ms.
Working with output stream class java.io.PrintStream
FORMULA TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-00 FALSE TECHNIQUES TOPOLOGICAL INITIAL_STATE
Incomplete random walk after 10024 steps, including 10 resets, run finished after 48 ms. (steps per millisecond=208 ) properties (out of 15) seen :6
FORMULA TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-15 TRUE TECHNIQUES TOPOLOGICAL RANDOM_WALK
FORMULA TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-14 TRUE TECHNIQUES TOPOLOGICAL RANDOM_WALK
FORMULA TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-13 FALSE TECHNIQUES TOPOLOGICAL RANDOM_WALK
FORMULA TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-11 FALSE TECHNIQUES TOPOLOGICAL RANDOM_WALK
FORMULA TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-09 TRUE TECHNIQUES TOPOLOGICAL RANDOM_WALK
FORMULA TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-03 TRUE TECHNIQUES TOPOLOGICAL RANDOM_WALK
Incomplete Best-First random walk after 10001 steps, including 2 resets, run finished after 132 ms. (steps per millisecond=75 ) properties (out of 9) seen :0
Incomplete Best-First random walk after 10001 steps, including 2 resets, run finished after 80 ms. (steps per millisecond=125 ) properties (out of 9) seen :0
Incomplete Best-First random walk after 10001 steps, including 2 resets, run finished after 68 ms. (steps per millisecond=147 ) properties (out of 9) seen :1
FORMULA TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-04 TRUE TECHNIQUES TOPOLOGICAL BESTFIRST_WALK
Incomplete Best-First random walk after 10000 steps, including 2 resets, run finished after 58 ms. (steps per millisecond=172 ) properties (out of 8) seen :0
Incomplete Best-First random walk after 10001 steps, including 2 resets, run finished after 75 ms. (steps per millisecond=133 ) properties (out of 8) seen :0
Incomplete Best-First random walk after 10000 steps, including 2 resets, run finished after 73 ms. (steps per millisecond=136 ) properties (out of 8) seen :0
Incomplete Best-First random walk after 10000 steps, including 18 resets, run finished after 63 ms. (steps per millisecond=158 ) properties (out of 8) seen :0
Incomplete Best-First random walk after 10000 steps, including 2 resets, run finished after 54 ms. (steps per millisecond=185 ) properties (out of 8) seen :0
Incomplete Best-First random walk after 10000 steps, including 2 resets, run finished after 41 ms. (steps per millisecond=243 ) properties (out of 8) seen :0
Running SMT prover for 8 properties.
// Phase 1: matrix 6 rows 8 cols
[2023-03-20 19:11:44] [INFO ] Computed 3 place invariants in 4 ms
[2023-03-20 19:11:44] [INFO ] [Real]Absence check using 3 positive place invariants in 1 ms returned sat
[2023-03-20 19:11:44] [INFO ] After 153ms SMT Verify possible using all constraints in real domain returned unsat :3 sat :0 real:5
[2023-03-20 19:11:44] [INFO ] [Nat]Absence check using 3 positive place invariants in 2 ms returned sat
[2023-03-20 19:11:44] [INFO ] After 55ms SMT Verify possible using all constraints in natural domain returned unsat :8 sat :0
FORMULA TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-12 TRUE TECHNIQUES STRUCTURAL_REDUCTION TOPOLOGICAL SAT_SMT
FORMULA TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-10 TRUE TECHNIQUES STRUCTURAL_REDUCTION TOPOLOGICAL SAT_SMT
FORMULA TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-08 FALSE TECHNIQUES STRUCTURAL_REDUCTION TOPOLOGICAL SAT_SMT
FORMULA TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-07 TRUE TECHNIQUES STRUCTURAL_REDUCTION TOPOLOGICAL SAT_SMT
FORMULA TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-06 TRUE TECHNIQUES STRUCTURAL_REDUCTION TOPOLOGICAL SAT_SMT
FORMULA TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-05 FALSE TECHNIQUES STRUCTURAL_REDUCTION TOPOLOGICAL SAT_SMT
FORMULA TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-02 TRUE TECHNIQUES STRUCTURAL_REDUCTION TOPOLOGICAL SAT_SMT
FORMULA TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-01 FALSE TECHNIQUES STRUCTURAL_REDUCTION TOPOLOGICAL SAT_SMT
Fused 8 Parikh solutions to 0 different solutions.
Parikh walk visited 0 properties in 0 ms.
All properties solved without resorting to model-checking.
Total runtime 1088 ms.
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//../reducer/bin//../../marcie/bin/marcie --net-file=model.pnml --mcc-file=ReachabilityCardinality.xml --memory=6 --mcc-mode

parse successfull
net created successfully

Net: TwoPhaseLocking_PT_nC00100vD
(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.714sec


RS generation: 0m 2.196sec


-> reachability set: #nodes 75582 (7.6e+04) #states 9,803,780 (6)



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

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

abstracting: (resB<=0)
states: 316,250 (5)
-> the formula is TRUE

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

MC time: 0m 1.971sec

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

abstracting: (haveAandB<=20)
states: 9,050,852 (6)
-> the formula is FALSE

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

MC time: 0m 0.736sec

checking: EF [Clients<=17]
normalized: E [true U Clients<=17]

abstracting: (Clients<=17)
states: 244,187 (5)
-> the formula is TRUE

FORMULA TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-14 TRUE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.231sec

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

abstracting: (resA<=16)
states: 7,307,279 (6)
-> the formula is TRUE

FORMULA TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-15 TRUE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.171sec

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

abstracting: (haveAandB<=haveAandB)
states: 9,803,780 (6)
-> the formula is FALSE

FORMULA TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-00 FALSE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.000sec

checking: AG [haveA<=Clients]
normalized: ~ [E [true U ~ [haveA<=Clients]]]

abstracting: (haveA<=Clients)
states: 9,349,235 (6)
-> the formula is FALSE

FORMULA TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-13 FALSE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 7.318sec

checking: AG [~ [[resA<=haveA2 & 52<=haveA2andB]]]
normalized: ~ [E [true U [resA<=haveA2 & 52<=haveA2andB]]]

abstracting: (52<=haveA2andB)
states: 0
abstracting: (resA<=haveA2)
states: 5,057,090 (6)
-> the formula is TRUE

FORMULA TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-02 TRUE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.162sec

checking: AG [[~ [[~ [haveA2<=89] | [[[resB<=56 | [haveA<=88 | haveAandB<=haveA]] & 29<=haveA2andB] & [37<=resA | 95<=haveA2]]]] | haveA<=17]]
normalized: ~ [E [true U ~ [[haveA<=17 | ~ [[[[37<=resA | 95<=haveA2] & [29<=haveA2andB & [resB<=56 | [haveA<=88 | haveAandB<=haveA]]]] | ~ [haveA2<=89]]]]]]]

abstracting: (haveA2<=89)
states: 9,803,780 (6)
abstracting: (haveAandB<=haveA)
states: 5,925,230 (6)
abstracting: (haveA<=88)
states: 9,803,780 (6)
abstracting: (resB<=56)
states: 9,803,780 (6)
abstracting: (29<=haveA2andB)
states: 172,040 (5)
abstracting: (95<=haveA2)
states: 0
abstracting: (37<=resA)
states: 109,004 (5)
abstracting: (haveA<=17)
states: 7,553,609 (6)
-> the formula is TRUE

FORMULA TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-12 TRUE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.498sec

checking: EF [[~ [[~ [[[haveAandB<=resA & haveA2andB<=haveA] | ~ [[~ [25<=resB] & [Clients<=haveA2andB | 50<=haveA2andB]]]]] & Clients<=8]] & 72<=haveA2andB]]
normalized: E [true U [72<=haveA2andB & ~ [[Clients<=8 & ~ [[~ [[[Clients<=haveA2andB | 50<=haveA2andB] & ~ [25<=resB]]] | [haveAandB<=resA & haveA2andB<=haveA]]]]]]]

abstracting: (haveA2andB<=haveA)
states: 5,925,230 (6)
abstracting: (haveAandB<=resA)
states: 5,925,230 (6)
abstracting: (25<=resB)
states: 2,550,366 (6)
abstracting: (50<=haveA2andB)
states: 1
abstracting: (Clients<=haveA2andB)
states: 1,325 (3)
abstracting: (Clients<=8)
states: 22,868 (4)
abstracting: (72<=haveA2andB)
states: 0
-> the formula is FALSE

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

MC time: 0m 4.006sec

checking: AG [[haveA2andB<=56 | [[~ [[[haveB<=haveAandB & 24<=haveB] & [[[Clients<=56 & resA<=resA] & ~ [94<=resB]] | [[[20<=haveA2 & 1<=resB] | [29<=haveA | haveA2andB<=51]] & Clients<=haveA]]]] | resA<=99] & [[[~ [resA<=haveA2andB] | haveB<=32] | ~ [resB<=haveA]] & haveA<=97]]]]
normalized: ~ [E [true U ~ [[haveA2andB<=56 | [[haveA<=97 & [~ [resB<=haveA] | [haveB<=32 | ~ [resA<=haveA2andB]]]] & [resA<=99 | ~ [[[[Clients<=haveA & [[29<=haveA | haveA2andB<=51] | [20<=haveA2 & 1<=resB]]] | [~ [94<=resB] & [Clients<=56 & resA<=resA]]] & [haveB<=haveAandB & 24<=haveB]]]]]]]]]

abstracting: (24<=haveB)
states: 2,778,866 (6)
abstracting: (haveB<=haveAandB)
states: 3,024,216 (6)
abstracting: (resA<=resA)
states: 9,803,780 (6)
abstracting: (Clients<=56)
states: 8,091,476 (6)
abstracting: (94<=resB)
states: 0
abstracting: (1<=resB)
states: 9,487,530 (6)
abstracting: (20<=haveA2)
states: 1,808,663 (6)
abstracting: (haveA2andB<=51)
states: 9,803,780 (6)
abstracting: (29<=haveA)
states: 538,890 (5)
abstracting: (Clients<=haveA)
states: 498,770 (5)
abstracting: (resA<=99)
states: 9,803,780 (6)
abstracting: (resA<=haveA2andB)
states: 4,267,925 (6)
abstracting: (haveB<=32)
states: 8,739,819 (6)
abstracting: (resB<=haveA)
states: 3,478,760 (6)
abstracting: (haveA<=97)
states: 9,803,780 (6)
abstracting: (haveA2andB<=56)
states: 9,803,780 (6)
-> the formula is TRUE

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

MC time: 0m 2.073sec

checking: EF [[[86<=haveA & ~ [[[27<=haveA2 & [[[~ [resB<=18] | [haveB<=49 | resB<=resB]] | [[haveA2<=98 | haveA2<=66] & ~ [62<=haveA]]] & ~ [haveAandB<=haveAandB]]] & ~ [haveB<=75]]]] | ~ [[[[[resB<=10 | resB<=86] | 70<=haveA2andB] | [[~ [haveB<=haveA] & 48<=haveA2andB] | [32<=haveB | [~ [53<=haveB] | [resB<=28 | 49<=resB]]]]] | [~ [resA<=haveA2andB] | haveB<=84]]]]]
normalized: E [true U [~ [[[haveB<=84 | ~ [resA<=haveA2andB]] | [[[32<=haveB | [[resB<=28 | 49<=resB] | ~ [53<=haveB]]] | [48<=haveA2andB & ~ [haveB<=haveA]]] | [70<=haveA2andB | [resB<=10 | resB<=86]]]]] | [86<=haveA & ~ [[~ [haveB<=75] & [27<=haveA2 & [~ [haveAandB<=haveAandB] & [[~ [62<=haveA] & [haveA2<=98 | haveA2<=66]] | [[haveB<=49 | resB<=resB] | ~ [resB<=18]]]]]]]]]]

abstracting: (resB<=18)
states: 5,764,580 (6)
abstracting: (resB<=resB)
states: 9,803,780 (6)
abstracting: (haveB<=49)
states: 9,802,455 (6)
abstracting: (haveA2<=66)
states: 9,803,780 (6)
abstracting: (haveA2<=98)
states: 9,803,780 (6)
abstracting: (62<=haveA)
states: 0
abstracting: (haveAandB<=haveAandB)
states: 9,803,780 (6)
abstracting: (27<=haveA2)
states: 733,589 (5)
abstracting: (haveB<=75)
states: 9,803,780 (6)
abstracting: (86<=haveA)
states: 0
abstracting: (resB<=86)
states: 9,803,780 (6)
abstracting: (resB<=10)
states: 3,446,156 (6)
abstracting: (70<=haveA2andB)
states: 0
abstracting: (haveB<=haveA)
states: 3,478,761 (6)
abstracting: (48<=haveA2andB)
states: 33
abstracting: (53<=haveB)
states: 0
abstracting: (49<=resB)
states: 5,202 (3)
abstracting: (resB<=28)
states: 8,076,296 (6)
abstracting: (32<=haveB)
states: 1,214,156 (6)
abstracting: (resA<=haveA2andB)
states: 4,267,925 (6)
abstracting: (haveB<=84)
states: 9,803,780 (6)
-> the formula is FALSE

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

MC time: 0m 1.444sec

checking: AG [~ [[[[[haveA<=Clients | [[28<=haveAandB & [~ [31<=haveA2] & haveA<=haveA2andB]] & haveB<=haveAandB]] & [[[~ [[haveA2<=39 & 6<=haveA2andB]] | [[haveA<=68 & Clients<=haveB] | ~ [haveB<=95]]] & ~ [[[haveB<=resA & 15<=haveA] | 6<=resA]]] | ~ [[33<=resA | haveA2andB<=resA]]]] & [~ [[~ [haveA<=87] | ~ [[~ [100<=resA] & ~ [haveA<=54]]]]] & [haveAandB<=79 | ~ [[haveA<=haveA2 & Clients<=Clients]]]]] & 62<=Clients]]]
normalized: ~ [E [true U [62<=Clients & [[[haveAandB<=79 | ~ [[haveA<=haveA2 & Clients<=Clients]]] & ~ [[~ [[~ [haveA<=54] & ~ [100<=resA]]] | ~ [haveA<=87]]]] & [[~ [[33<=resA | haveA2andB<=resA]] | [~ [[6<=resA | [haveB<=resA & 15<=haveA]]] & [[~ [haveB<=95] | [haveA<=68 & Clients<=haveB]] | ~ [[haveA2<=39 & 6<=haveA2andB]]]]] & [haveA<=Clients | [haveB<=haveAandB & [28<=haveAandB & [haveA<=haveA2andB & ~ [31<=haveA2]]]]]]]]]]

abstracting: (31<=haveA2)
states: 384,306 (5)
abstracting: (haveA<=haveA2andB)
states: 4,267,925 (6)
abstracting: (28<=haveAandB)
states: 212,290 (5)
abstracting: (haveB<=haveAandB)
states: 3,024,216 (6)
abstracting: (haveA<=Clients)
states: 9,349,235 (6)
abstracting: (6<=haveA2andB)
states: 5,331,492 (6)
abstracting: (haveA2<=39)
states: 9,756,734 (6)
abstracting: (Clients<=haveB)
states: 1,366,910 (6)
abstracting: (haveA<=68)
states: 9,803,780 (6)
abstracting: (haveB<=95)
states: 9,803,780 (6)
abstracting: (15<=haveA)
states: 3,043,287 (6)
abstracting: (haveB<=resA)
states: 3,478,761 (6)
abstracting: (6<=resA)
states: 6,498,972 (6)
abstracting: (haveA2andB<=resA)
states: 5,925,230 (6)
abstracting: (33<=resA)
states: 264,537 (5)
abstracting: (haveA<=87)
states: 9,803,780 (6)
abstracting: (100<=resA)
states: 0
abstracting: (haveA<=54)
states: 9,803,780 (6)
abstracting: (Clients<=Clients)
states: 9,803,780 (6)
abstracting: (haveA<=haveA2)
states: 5,057,090 (6)
abstracting: (haveAandB<=79)
states: 9,803,780 (6)
abstracting: (62<=Clients)
states: 962,598 (5)
-> the formula is TRUE

FORMULA TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-06 TRUE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 2.446sec

checking: EF [[~ [[~ [[[~ [[[Clients<=66 & Clients<=haveAandB] | [42<=resA & haveA<=Clients]]] & resB<=46] | [~ [haveA2<=66] | [[[12<=Clients & resB<=47] & [56<=resA & haveA2<=haveAandB]] | ~ [haveAandB<=haveA]]]]] | [[haveA2andB<=93 | ~ [[Clients<=haveA2andB & ~ [resB<=77]]]] | [[[~ [resB<=haveAandB] | [[16<=haveA | haveB<=97] & [haveAandB<=haveA2 | haveA2andB<=haveAandB]]] | resB<=57] & ~ [[haveA2andB<=haveA2 & ~ [[15<=haveAandB & 34<=haveA]]]]]]]] & haveAandB<=23]]
normalized: E [true U [haveAandB<=23 & ~ [[[[~ [[haveA2andB<=haveA2 & ~ [[15<=haveAandB & 34<=haveA]]]] & [resB<=57 | [[[haveAandB<=haveA2 | haveA2andB<=haveAandB] & [16<=haveA | haveB<=97]] | ~ [resB<=haveAandB]]]] | [haveA2andB<=93 | ~ [[Clients<=haveA2andB & ~ [resB<=77]]]]] | ~ [[[[~ [haveAandB<=haveA] | [[56<=resA & haveA2<=haveAandB] & [12<=Clients & resB<=47]]] | ~ [haveA2<=66]] | [resB<=46 & ~ [[[42<=resA & haveA<=Clients] | [Clients<=66 & Clients<=haveAandB]]]]]]]]]]

abstracting: (Clients<=haveAandB)
states: 1,325 (3)
abstracting: (Clients<=66)
states: 9,301,838 (6)
abstracting: (haveA<=Clients)
states: 9,349,235 (6)
abstracting: (42<=resA)
states: 23,661 (4)
abstracting: (resB<=46)
states: 9,778,772 (6)
abstracting: (haveA2<=66)
states: 9,803,780 (6)
abstracting: (resB<=47)
states: 9,791,027 (6)
abstracting: (12<=Clients)
states: 9,743,175 (6)
abstracting: (haveA2<=haveAandB)
states: 4,267,926 (6)
abstracting: (56<=resA)
states: 0
abstracting: (haveAandB<=haveA)
states: 5,925,230 (6)
abstracting: (resB<=77)
states: 9,803,780 (6)
abstracting: (Clients<=haveA2andB)
states: 1,325 (3)
abstracting: (haveA2andB<=93)
states: 9,803,780 (6)
abstracting: (resB<=haveAandB)
states: 3,024,215 (6)
abstracting: (haveB<=97)
states: 9,803,780 (6)
abstracting: (16<=haveA)
states: 2,760,681 (6)
abstracting: (haveA2andB<=haveAandB)
states: 5,136,065 (6)
abstracting: (haveAandB<=haveA2)
states: 5,925,230 (6)
abstracting: (resB<=57)
states: 9,803,780 (6)
abstracting: (34<=haveA)
states: 216,087 (5)
abstracting: (15<=haveAandB)
states: 1,809,522 (6)
abstracting: (haveA2andB<=haveA2)
states: 5,925,230 (6)
abstracting: (haveAandB<=23)
states: 9,348,857 (6)
-> the formula is FALSE

FORMULA TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-05 FALSE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 4.451sec

checking: AG [[~ [haveA<=15] | [[~ [80<=resA] | [[[[[[haveA2<=91 | haveAandB<=resA] & [haveA2<=69 | 13<=resA]] | haveAandB<=9] & [haveAandB<=37 | resA<=5]] & [[Clients<=haveA & [~ [49<=haveA2andB] | ~ [resB<=haveA]]] | ~ [[~ [42<=resB] & 68<=resB]]]] | [Clients<=haveA | ~ [[~ [haveA2andB<=2] & haveA2andB<=resA]]]]] | [[resB<=resB & [[haveAandB<=18 & haveB<=37] | ~ [[~ [[65<=haveA | haveA2<=64]] | ~ [[42<=haveA2 & 55<=haveAandB]]]]]] & [[[~ [[[haveA<=resA | Clients<=haveA] & [haveA<=46 | haveA<=51]]] | [[[haveA<=11 | resB<=Clients] | resA<=1] | [haveA<=2 | [resA<=55 | haveB<=83]]]] & ~ [[~ [[haveAandB<=8 | haveA2<=22]] & 89<=haveA]]] & ~ [[[68<=haveA & 33<=haveA2andB] | [[~ [haveA2<=haveB] | [resA<=27 | Clients<=41]] & ~ [haveB<=63]]]]]]]]]
normalized: ~ [E [true U ~ [[[[[~ [[[~ [haveB<=63] & [[resA<=27 | Clients<=41] | ~ [haveA2<=haveB]]] | [68<=haveA & 33<=haveA2andB]]] & [~ [[89<=haveA & ~ [[haveAandB<=8 | haveA2<=22]]]] & [[[haveA<=2 | [resA<=55 | haveB<=83]] | [resA<=1 | [haveA<=11 | resB<=Clients]]] | ~ [[[haveA<=46 | haveA<=51] & [haveA<=resA | Clients<=haveA]]]]]] & [resB<=resB & [~ [[~ [[42<=haveA2 & 55<=haveAandB]] | ~ [[65<=haveA | haveA2<=64]]]] | [haveAandB<=18 & haveB<=37]]]] | [[[Clients<=haveA | ~ [[haveA2andB<=resA & ~ [haveA2andB<=2]]]] | [[~ [[68<=resB & ~ [42<=resB]]] | [Clients<=haveA & [~ [resB<=haveA] | ~ [49<=haveA2andB]]]] & [[haveAandB<=37 | resA<=5] & [haveAandB<=9 | [[haveA2<=69 | 13<=resA] & [haveA2<=91 | haveAandB<=resA]]]]]] | ~ [80<=resA]]] | ~ [haveA<=15]]]]]

abstracting: (haveA<=15)
states: 7,043,099 (6)
abstracting: (80<=resA)
states: 0
abstracting: (haveAandB<=resA)
states: 5,925,230 (6)
abstracting: (haveA2<=91)
states: 9,803,780 (6)
abstracting: (13<=resA)
states: 3,665,974 (6)
abstracting: (haveA2<=69)
states: 9,803,780 (6)
abstracting: (haveAandB<=9)
states: 6,410,005 (6)
abstracting: (resA<=5)
states: 3,304,808 (6)
abstracting: (haveAandB<=37)
states: 9,788,856 (6)
abstracting: (49<=haveA2andB)
states: 8
abstracting: (resB<=haveA)
states: 3,478,760 (6)
abstracting: (Clients<=haveA)
states: 498,770 (5)
abstracting: (42<=resB)
states: 186,516 (5)
abstracting: (68<=resB)
states: 0
abstracting: (haveA2andB<=2)
states: 2,506,700 (6)
abstracting: (haveA2andB<=resA)
states: 5,925,230 (6)
abstracting: (Clients<=haveA)
states: 498,770 (5)
abstracting: (haveB<=37)
states: 9,330,672 (6)
abstracting: (haveAandB<=18)
states: 8,777,524 (6)
abstracting: (haveA2<=64)
states: 9,803,780 (6)
abstracting: (65<=haveA)
states: 0
abstracting: (55<=haveAandB)
states: 0
abstracting: (42<=haveA2)
states: 23,660 (4)
abstracting: (resB<=resB)
states: 9,803,780 (6)
abstracting: (Clients<=haveA)
states: 498,770 (5)
abstracting: (haveA<=resA)
states: 5,057,090 (6)
abstracting: (haveA<=51)
states: 9,803,780 (6)
abstracting: (haveA<=46)
states: 9,802,037 (6)
abstracting: (resB<=Clients)
states: 9,803,780 (6)
abstracting: (haveA<=11)
states: 5,796,686 (6)
abstracting: (resA<=1)
states: 1,194,725 (6)
abstracting: (haveB<=83)
states: 9,803,780 (6)
abstracting: (resA<=55)
states: 9,803,780 (6)
abstracting: (haveA<=2)
states: 1,757,000 (6)
abstracting: (haveA2<=22)
states: 8,538,888 (6)
abstracting: (haveAandB<=8)
states: 5,989,508 (6)
abstracting: (89<=haveA)
states: 0
abstracting: (33<=haveA2andB)
states: 67,032 (4)
abstracting: (68<=haveA)
states: 0
abstracting: (haveA2<=haveB)
states: 6,641,270 (6)
abstracting: (Clients<=41)
states: 3,933,467 (6)
abstracting: (resA<=27)
states: 9,172,890 (6)
abstracting: (haveB<=63)
states: 9,803,780 (6)
-> the formula is TRUE

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

MC time: 0m 3.874sec

checking: EF [[[[85<=resB | resA<=haveA2] & ~ [[~ [[[resB<=43 & ~ [[resA<=43 & resA<=haveA]]] & ~ [haveAandB<=resA]]] & [[~ [[[resB<=haveAandB | haveA2andB<=98] & [haveA2andB<=Clients & haveAandB<=21]]] & [[~ [64<=haveAandB] & [71<=haveA & 53<=haveAandB]] | 72<=haveA2andB]] | [[haveA<=haveA2andB | [[78<=haveA2andB & 82<=haveA2andB] | [haveA2andB<=93 | haveB<=59]]] | [[[resB<=haveB | haveA2andB<=37] & ~ [94<=haveB]] & ~ [[haveA<=91 & haveB<=30]]]]]]]] & [~ [resA<=51] | [~ [[[~ [83<=haveA] & haveA2<=resA] | [[[~ [haveA2andB<=haveB] | [42<=haveB | 92<=Clients]] & [~ [haveA<=resA] & ~ [resB<=94]]] | ~ [[[resB<=resB & 3<=haveAandB] | [haveA<=haveA | 50<=haveA]]]]]] | ~ [[~ [[~ [resB<=94] & [77<=resB | resA<=haveA]]] & [[[86<=haveA & resA<=90] | ~ [haveB<=70]] | [~ [35<=haveA2] & ~ [haveAandB<=haveB]]]]]]]]]
normalized: E [true U [[[~ [[~ [[~ [resB<=94] & [77<=resB | resA<=haveA]]] & [[~ [haveAandB<=haveB] & ~ [35<=haveA2]] | [~ [haveB<=70] | [86<=haveA & resA<=90]]]]] | ~ [[[~ [[[haveA<=haveA | 50<=haveA] | [resB<=resB & 3<=haveAandB]]] | [[~ [resB<=94] & ~ [haveA<=resA]] & [[42<=haveB | 92<=Clients] | ~ [haveA2andB<=haveB]]]] | [haveA2<=resA & ~ [83<=haveA]]]]] | ~ [resA<=51]] & [~ [[[[[~ [[haveA<=91 & haveB<=30]] & [~ [94<=haveB] & [resB<=haveB | haveA2andB<=37]]] | [haveA<=haveA2andB | [[haveA2andB<=93 | haveB<=59] | [78<=haveA2andB & 82<=haveA2andB]]]] | [[72<=haveA2andB | [[71<=haveA & 53<=haveAandB] & ~ [64<=haveAandB]]] & ~ [[[haveA2andB<=Clients & haveAandB<=21] & [resB<=haveAandB | haveA2andB<=98]]]]] & ~ [[~ [haveAandB<=resA] & [resB<=43 & ~ [[resA<=43 & resA<=haveA]]]]]]] & [85<=resB | resA<=haveA2]]]]

abstracting: (resA<=haveA2)
states: 5,057,090 (6)
abstracting: (85<=resB)
states: 0
abstracting: (resA<=haveA)
states: 5,057,090 (6)
abstracting: (resA<=43)
states: 9,793,574 (6)
abstracting: (resB<=43)
states: 9,704,870 (6)
abstracting: (haveAandB<=resA)
states: 5,925,230 (6)
abstracting: (haveA2andB<=98)
states: 9,803,780 (6)
abstracting: (resB<=haveAandB)
states: 3,024,215 (6)
abstracting: (haveAandB<=21)
states: 9,163,692 (6)
abstracting: (haveA2andB<=Clients)
states: 9,803,780 (6)
abstracting: (64<=haveAandB)
states: 0
abstracting: (53<=haveAandB)
states: 0
abstracting: (71<=haveA)
states: 0
abstracting: (72<=haveA2andB)
states: 0
abstracting: (82<=haveA2andB)
states: 0
abstracting: (78<=haveA2andB)
states: 0
abstracting: (haveB<=59)
states: 9,803,780 (6)
abstracting: (haveA2andB<=93)
states: 9,803,780 (6)
abstracting: (haveA<=haveA2andB)
states: 4,267,925 (6)
abstracting: (haveA2andB<=37)
states: 9,788,856 (6)
abstracting: (resB<=haveB)
states: 4,981,040 (6)
abstracting: (94<=haveB)
states: 0
abstracting: (haveB<=30)
states: 8,428,869 (6)
abstracting: (haveA<=91)
states: 9,803,780 (6)
abstracting: (resA<=51)
states: 9,803,780 (6)
abstracting: (83<=haveA)
states: 0
abstracting: (haveA2<=resA)
states: 5,057,091 (6)
abstracting: (haveA2andB<=haveB)
states: 7,054,865 (6)
abstracting: (92<=Clients)
states: 1,287 (3)
abstracting: (42<=haveB)
states: 186,515 (5)
abstracting: (haveA<=resA)
states: 5,057,090 (6)
abstracting: (resB<=94)
states: 9,803,780 (6)
abstracting: (3<=haveAandB)
states: 7,297,080 (6)
abstracting: (resB<=resB)
states: 9,803,780 (6)
abstracting: (50<=haveA)
states: 51
abstracting: (haveA<=haveA)
states: 9,803,780 (6)
abstracting: (resA<=90)
states: 9,803,780 (6)
abstracting: (86<=haveA)
states: 0
abstracting: (haveB<=70)
states: 9,803,780 (6)
abstracting: (35<=haveA2)
states: 174,419 (5)
abstracting: (haveAandB<=haveB)
states: 7,054,865 (6)
abstracting: (resA<=haveA)
states: 5,057,090 (6)
abstracting: (77<=resB)
states: 0
abstracting: (resB<=94)
states: 9,803,780 (6)
-> the formula is TRUE

FORMULA TwoPhaseLocking-PT-nC00100vD-ReachabilityCardinality-04 TRUE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m11.003sec

checking: EF [[[[[[[~ [resA<=resA] | ~ [resB<=18]] | ~ [haveA2andB<=haveAandB]] & [[Clients<=Clients & [haveA2andB<=14 | haveB<=90]] & 91<=Clients]] | [[[[haveA2<=haveA | haveA<=haveA2] & [[[resB<=9 | haveA2andB<=resB] & ~ [79<=haveA]] & [[haveAandB<=haveA & haveA2andB<=98] & Clients<=haveB]]] | ~ [13<=haveA]] | [~ [[[[haveA2andB<=haveA2 | Clients<=haveAandB] | [haveAandB<=66 & haveB<=0]] | Clients<=46]] & [haveA<=16 & [[[resA<=86 & 71<=resB] & 19<=resA] & [haveA2<=25 & ~ [Clients<=23]]]]]]] & [[~ [[[[[Clients<=45 | haveB<=haveA] | haveA<=haveA2] & haveA<=30] & [[~ [resA<=32] | ~ [haveB<=56]] & [[54<=haveA & resA<=resA] & [24<=resB & resA<=67]]]]] & [[[[haveB<=40 & [80<=Clients | 75<=haveA]] & ~ [resB<=71]] & resB<=haveB] & resA<=haveAandB]] | [[~ [16<=haveAandB] & ~ [[[resA<=72 & ~ [haveA<=0]] | 26<=haveB]]] | [[[50<=Clients | 56<=Clients] & ~ [[[resB<=haveAandB & haveB<=47] & [Clients<=60 & haveAandB<=Clients]]]] | [[Clients<=9 & [[haveA2andB<=37 & 43<=Clients] & [haveB<=12 & 80<=resA]]] | [[~ [61<=haveB] | [81<=haveA & haveAandB<=haveA2]] | 74<=haveAandB]]]]]] & 25<=haveB]]
normalized: E [true U [25<=haveB & [[[[[[Clients<=9 & [[haveA2andB<=37 & 43<=Clients] & [haveB<=12 & 80<=resA]]] | [74<=haveAandB | [[81<=haveA & haveAandB<=haveA2] | ~ [61<=haveB]]]] | [~ [[[Clients<=60 & haveAandB<=Clients] & [resB<=haveAandB & haveB<=47]]] & [50<=Clients | 56<=Clients]]] | [~ [[26<=haveB | [resA<=72 & ~ [haveA<=0]]]] & ~ [16<=haveAandB]]] | [[resA<=haveAandB & [resB<=haveB & [~ [resB<=71] & [haveB<=40 & [80<=Clients | 75<=haveA]]]]] & ~ [[[[[24<=resB & resA<=67] & [54<=haveA & resA<=resA]] & [~ [haveB<=56] | ~ [resA<=32]]] & [haveA<=30 & [haveA<=haveA2 | [Clients<=45 | haveB<=haveA]]]]]]] & [[[[haveA<=16 & [[haveA2<=25 & ~ [Clients<=23]] & [19<=resA & [resA<=86 & 71<=resB]]]] & ~ [[Clients<=46 | [[haveAandB<=66 & haveB<=0] | [haveA2andB<=haveA2 | Clients<=haveAandB]]]]] | [~ [13<=haveA] | [[[Clients<=haveB & [haveAandB<=haveA & haveA2andB<=98]] & [~ [79<=haveA] & [resB<=9 | haveA2andB<=resB]]] & [haveA2<=haveA | haveA<=haveA2]]]] | [[91<=Clients & [Clients<=Clients & [haveA2andB<=14 | haveB<=90]]] & [~ [haveA2andB<=haveAandB] | [~ [resB<=18] | ~ [resA<=resA]]]]]]]]

abstracting: (resA<=resA)
states: 9,803,780 (6)
abstracting: (resB<=18)
states: 5,764,580 (6)
abstracting: (haveA2andB<=haveAandB)
states: 5,136,065 (6)
abstracting: (haveB<=90)
states: 9,803,780 (6)
abstracting: (haveA2andB<=14)
states: 7,994,258 (6)
abstracting: (Clients<=Clients)
states: 9,803,780 (6)
abstracting: (91<=Clients)
states: 2,002 (3)
abstracting: (haveA<=haveA2)
states: 5,057,090 (6)
abstracting: (haveA2<=haveA)
states: 5,057,091 (6)
abstracting: (haveA2andB<=resB)
states: 7,054,865 (6)
abstracting: (resB<=9)
states: 3,139,640 (6)
abstracting: (79<=haveA)
states: 0
abstracting: (haveA2andB<=98)
states: 9,803,780 (6)
abstracting: (haveAandB<=haveA)
states: 5,925,230 (6)
abstracting: (Clients<=haveB)
states: 1,366,910 (6)
abstracting: (13<=haveA)
states: 3,665,974 (6)
abstracting: (Clients<=haveAandB)
states: 1,325 (3)
abstracting: (haveA2andB<=haveA2)
states: 5,925,230 (6)
abstracting: (haveB<=0)
states: 316,251 (5)
abstracting: (haveAandB<=66)
states: 9,803,780 (6)
abstracting: (Clients<=46)
states: 5,389,019 (6)
abstracting: (71<=resB)
states: 0
abstracting: (resA<=86)
states: 9,803,780 (6)
abstracting: (19<=resA)
states: 2,021,096 (6)
abstracting: (Clients<=23)
states: 652,859 (5)
abstracting: (haveA2<=25)
states: 8,956,116 (6)
abstracting: (haveA<=16)
states: 7,307,279 (6)
abstracting: (haveB<=haveA)
states: 3,478,761 (6)
abstracting: (Clients<=45)
states: 5,085,023 (6)
abstracting: (haveA<=haveA2)
states: 5,057,090 (6)
abstracting: (haveA<=30)
states: 9,419,473 (6)
abstracting: (resA<=32)
states: 9,539,243 (6)
abstracting: (haveB<=56)
states: 9,803,780 (6)
abstracting: (resA<=resA)
states: 9,803,780 (6)
abstracting: (54<=haveA)
states: 0
abstracting: (resA<=67)
states: 9,803,780 (6)
abstracting: (24<=resB)
states: 2,778,867 (6)
abstracting: (75<=haveA)
states: 0
abstracting: (80<=Clients)
states: 53,130 (4)
abstracting: (haveB<=40)
states: 9,560,175 (6)
abstracting: (resB<=71)
states: 9,803,780 (6)
abstracting: (resB<=haveB)
states: 4,981,040 (6)
abstracting: (resA<=haveAandB)
states: 4,267,925 (6)
abstracting: (16<=haveAandB)
states: 1,579,641 (6)
abstracting: (haveA<=0)
states: 609,075 (5)
abstracting: (resA<=72)
states: 9,803,780 (6)
abstracting: (26<=haveB)
states: 2,330,639 (6)
abstracting: (56<=Clients)
states: 1,906,884 (6)
abstracting: (50<=Clients)
states: 3,478,761 (6)
abstracting: (haveB<=47)
states: 9,791,028 (6)
abstracting: (resB<=haveAandB)
states: 3,024,215 (6)
abstracting: (haveAandB<=Clients)
states: 9,803,780 (6)
abstracting: (Clients<=60)
states: 8,717,772 (6)
abstracting: (61<=haveB)
states: 0
abstracting: (haveAandB<=haveA2)
states: 5,925,230 (6)
abstracting: (81<=haveA)
states: 0
abstracting: (74<=haveAandB)
states: 0
abstracting: (80<=resA)
states: 0
abstracting: (haveB<=12)
states: 4,050,657 (6)
abstracting: (43<=Clients)
states: 5,593,608 (6)
abstracting: (haveA2andB<=37)
states: 9,788,856 (6)
abstracting: (Clients<=9)
states: 32,603 (4)
abstracting: (25<=haveB)
states: 2,550,365 (6)
-> the formula is TRUE

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

MC time: 0m 6.313sec

totally nodes used: 3522643 (3.5e+06)
number of garbage collections: 0
fire ops cache: hits/miss/sum: 59061974 7958001 67019975
used/not used/entry size/cache size: 10243398 56865466 16 1024MB
basic ops cache: hits/miss/sum: 52470887 29475006 81945893
used/not used/entry size/cache size: 14195419 2581797 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: 7684608 2006521 9691129
used/not used/entry size/cache size: 1680053 6708555 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 63894673
1 3070949
2 116250
3 13806
4 3479
5 1603
6 962
7 949
8 701
9 642
>= 10 4850

Total processing time: 0m53.967sec


BK_STOP 1679339559282

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

+ ulimit -s 65536
+ [[ -z '' ]]
+ export LTSMIN_MEM_SIZE=8589934592
+ LTSMIN_MEM_SIZE=8589934592
+ export PYTHONPATH=/home/mcc/BenchKit/itstools/pylibs
+ PYTHONPATH=/home/mcc/BenchKit/itstools/pylibs
+ export LD_LIBRARY_PATH=/home/mcc/BenchKit/itstools/pylibs:
+ LD_LIBRARY_PATH=/home/mcc/BenchKit/itstools/pylibs:
++ sed s/.jar//
++ perl -pe 's/.*\.//g'
++ ls /home/mcc/BenchKit/bin//../reducer/bin//../../itstools//itstools/plugins/fr.lip6.move.gal.application.pnmcc_1.0.0.202303021504.jar
+ VERSION=202303021504
+ echo 'Running Version 202303021504'
+ /home/mcc/BenchKit/bin//../reducer/bin//../../itstools//itstools/its-tools -pnfolder /home/mcc/execution -examination ReachabilityCardinality -timeout 360 -rebuildPNML
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:1348 (224), effective:447 (74)

initing FirstDep: 0m 0.000sec


iterations count:256 (42), effective:150 (25)

iterations count:542 (90), effective:186 (31)

iterations count:568 (94), effective:215 (35)

iterations count:74 (12), effective:34 (5)

iterations count:541 (90), effective:179 (29)

iterations count:985 (164), effective:345 (57)

iterations count:429 (71), effective:174 (29)

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-nC00100vD"
export BK_EXAMINATION="ReachabilityCardinality"
export BK_TOOL="marciexred"
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 marciexred"
echo " Input is TwoPhaseLocking-PT-nC00100vD, examination is ReachabilityCardinality"
echo " Time confinement is $BK_TIME_CONFINEMENT seconds"
echo " Memory confinement is 16384 MBytes"
echo " Number of cores is 4"
echo " Run identifier is r490-tall-167912709200838"
echo "====================================================================="
echo
echo "--------------------"
echo "preparation of the directory to be used:"

tar xzf /home/mcc/BenchKit/INPUTS/TwoPhaseLocking-PT-nC00100vD.tgz
mv TwoPhaseLocking-PT-nC00100vD 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 ;