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-167912709100806.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-nC00020vD, examination is ReachabilityCardinality
Time confinement is 3600 seconds
Memory confinement is 16384 MBytes
Number of cores is 4
Run identifier is r490-tall-167912709100806
=====================================================================

--------------------
preparation of the directory to be used:
/home/mcc/execution
total 440K
-rw-r--r-- 1 mcc users 7.9K Feb 25 17:35 CTLCardinality.txt
-rw-r--r-- 1 mcc users 80K Feb 25 17:35 CTLCardinality.xml
-rw-r--r-- 1 mcc users 4.9K Feb 25 17:33 CTLFireability.txt
-rw-r--r-- 1 mcc users 41K Feb 25 17:33 CTLFireability.xml
-rw-r--r-- 1 mcc users 3.8K Feb 25 17:22 LTLCardinality.txt
-rw-r--r-- 1 mcc users 25K Feb 25 17:22 LTLCardinality.xml
-rw-r--r-- 1 mcc users 2.4K Feb 25 17:22 LTLFireability.txt
-rw-r--r-- 1 mcc users 18K Feb 25 17:22 LTLFireability.xml
-rw-r--r-- 1 mcc users 11K Feb 25 17:36 ReachabilityCardinality.txt
-rw-r--r-- 1 mcc users 103K Feb 25 17:36 ReachabilityCardinality.xml
-rw-r--r-- 1 mcc users 11K Feb 25 17:36 ReachabilityFireability.txt
-rw-r--r-- 1 mcc users 88K Feb 25 17:36 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-nC00020vD-ReachabilityCardinality-00
FORMULA_NAME TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-01
FORMULA_NAME TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-02
FORMULA_NAME TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-03
FORMULA_NAME TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-04
FORMULA_NAME TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-05
FORMULA_NAME TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-06
FORMULA_NAME TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-07
FORMULA_NAME TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-08
FORMULA_NAME TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-09
FORMULA_NAME TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-10
FORMULA_NAME TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-11
FORMULA_NAME TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-12
FORMULA_NAME TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-13
FORMULA_NAME TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-14
FORMULA_NAME TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-15

=== Now, execution of the tool begins

BK_START 1679339148879

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-nC00020vD
Applying reductions before tool marcie
Invoking reducer
Running Version 202303021504
[2023-03-20 19:05:50] [INFO ] Running its-tools with arguments : [-pnfolder, /home/mcc/execution, -examination, ReachabilityCardinality, -timeout, 360, -rebuildPNML]
[2023-03-20 19:05:50] [INFO ] Parsing pnml file : /home/mcc/execution/model.pnml
[2023-03-20 19:05:50] [INFO ] Load time of PNML (sax parser for PT used): 18 ms
[2023-03-20 19:05:50] [INFO ] Transformed 8 places.
[2023-03-20 19:05:50] [INFO ] Transformed 6 transitions.
[2023-03-20 19:05:50] [INFO ] Parsed PT model containing 8 places and 6 transitions and 18 arcs in 93 ms.
Parsed 16 properties from file /home/mcc/execution/ReachabilityCardinality.xml in 15 ms.
Working with output stream class java.io.PrintStream
FORMULA TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-00 TRUE TECHNIQUES TOPOLOGICAL INITIAL_STATE
FORMULA TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-01 TRUE TECHNIQUES TOPOLOGICAL INITIAL_STATE
FORMULA TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-09 TRUE TECHNIQUES TOPOLOGICAL INITIAL_STATE
Incomplete random walk after 10000 steps, including 82 resets, run finished after 191 ms. (steps per millisecond=52 ) properties (out of 13) seen :0
Incomplete Best-First random walk after 10000 steps, including 94 resets, run finished after 177 ms. (steps per millisecond=56 ) properties (out of 13) seen :0
Incomplete Best-First random walk after 10001 steps, including 12 resets, run finished after 133 ms. (steps per millisecond=75 ) properties (out of 13) seen :0
Incomplete Best-First random walk after 10001 steps, including 2 resets, run finished after 188 ms. (steps per millisecond=53 ) properties (out of 13) seen :0
Incomplete Best-First random walk after 10001 steps, including 2 resets, run finished after 123 ms. (steps per millisecond=81 ) properties (out of 13) seen :0
Incomplete Best-First random walk after 10001 steps, including 66 resets, run finished after 94 ms. (steps per millisecond=106 ) properties (out of 13) seen :0
Incomplete Best-First random walk after 10001 steps, including 4 resets, run finished after 53 ms. (steps per millisecond=188 ) properties (out of 13) seen :0
Incomplete Best-First random walk after 10000 steps, including 6 resets, run finished after 58 ms. (steps per millisecond=172 ) properties (out of 13) seen :0
Incomplete Best-First random walk after 10000 steps, including 4 resets, run finished after 56 ms. (steps per millisecond=178 ) properties (out of 13) seen :0
Incomplete Best-First random walk after 10001 steps, including 2 resets, run finished after 45 ms. (steps per millisecond=222 ) properties (out of 13) seen :0
Incomplete Best-First random walk after 10001 steps, including 2 resets, run finished after 46 ms. (steps per millisecond=217 ) properties (out of 13) seen :0
Incomplete Best-First random walk after 10001 steps, including 2 resets, run finished after 48 ms. (steps per millisecond=208 ) properties (out of 13) seen :0
Incomplete Best-First random walk after 10000 steps, including 10 resets, run finished after 63 ms. (steps per millisecond=158 ) properties (out of 13) seen :0
Incomplete Best-First random walk after 10001 steps, including 2 resets, run finished after 46 ms. (steps per millisecond=217 ) properties (out of 13) seen :0
Probably explored full state space saw : 7006 states, properties seen :0
Probabilistic random walk after 35891 steps, saw 7006 distinct states, run finished after 201 ms. (steps per millisecond=178 ) properties seen :0
Explored full state space saw : 7006 states, properties seen :0
Exhaustive walk after 35891 steps, saw 7006 distinct states, run finished after 165 ms. (steps per millisecond=217 ) properties seen :0
FORMULA TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-15 TRUE TECHNIQUES TOPOLOGICAL EXHAUSTIVE_WALK
FORMULA TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-14 TRUE TECHNIQUES TOPOLOGICAL EXHAUSTIVE_WALK
FORMULA TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-13 TRUE TECHNIQUES TOPOLOGICAL EXHAUSTIVE_WALK
FORMULA TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-12 TRUE TECHNIQUES TOPOLOGICAL EXHAUSTIVE_WALK
FORMULA TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-11 TRUE TECHNIQUES TOPOLOGICAL EXHAUSTIVE_WALK
FORMULA TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-10 TRUE TECHNIQUES TOPOLOGICAL EXHAUSTIVE_WALK
FORMULA TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-08 TRUE TECHNIQUES TOPOLOGICAL EXHAUSTIVE_WALK
FORMULA TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-07 TRUE TECHNIQUES TOPOLOGICAL EXHAUSTIVE_WALK
FORMULA TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-06 TRUE TECHNIQUES TOPOLOGICAL EXHAUSTIVE_WALK
FORMULA TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-05 TRUE TECHNIQUES TOPOLOGICAL EXHAUSTIVE_WALK
FORMULA TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-04 FALSE TECHNIQUES TOPOLOGICAL EXHAUSTIVE_WALK
FORMULA TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-03 TRUE TECHNIQUES TOPOLOGICAL EXHAUSTIVE_WALK
FORMULA TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-02 FALSE TECHNIQUES TOPOLOGICAL EXHAUSTIVE_WALK
All properties solved without resorting to model-checking.
Total runtime 1838 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_nC00020vD
(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.775sec


RS generation: 0m 0.006sec


-> reachability set: #nodes 1122 (1.1e+03) #states 7,006 (3)



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

checking: AG [haveA2<=18]
normalized: ~ [E [true U ~ [haveA2<=18]]]

abstracting: (haveA2<=18)
states: 7,006 (3)
-> the formula is TRUE

FORMULA TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-08 TRUE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.000sec

checking: AG [resA<=11]
normalized: ~ [E [true U ~ [resA<=11]]]

abstracting: (resA<=11)
states: 7,006 (3)
-> the formula is TRUE

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

MC time: 0m 0.000sec

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

abstracting: (resB<=19)
states: 7,006 (3)
-> the formula is TRUE

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

MC time: 0m 0.000sec

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

abstracting: (haveA<=haveA)
states: 7,006 (3)
-> the formula is TRUE

FORMULA TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-01 TRUE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.000sec

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

abstracting: (haveA<=haveA)
states: 7,006 (3)
-> the formula is TRUE

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

MC time: 0m 0.000sec

checking: EF [~ [[haveA2<=13 & resB<=Clients]]]
normalized: E [true U ~ [[haveA2<=13 & resB<=Clients]]]

abstracting: (resB<=Clients)
states: 7,006 (3)
abstracting: (haveA2<=13)
states: 7,006 (3)
-> the formula is FALSE

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

MC time: 0m 0.001sec

checking: AG [~ [[[18<=haveA | ~ [resA<=haveA2andB]] & [~ [[19<=haveA2andB & [~ [[[Clients<=haveA2andB & haveA<=0] | haveAandB<=haveAandB]] & Clients<=resB]]] & [14<=resB & 17<=Clients]]]]]
normalized: ~ [E [true U [[[14<=resB & 17<=Clients] & ~ [[[~ [[[Clients<=haveA2andB & haveA<=0] | haveAandB<=haveAandB]] & Clients<=resB] & 19<=haveA2andB]]] & [~ [resA<=haveA2andB] | 18<=haveA]]]]

abstracting: (18<=haveA)
states: 0
abstracting: (resA<=haveA2andB)
states: 3,485 (3)
abstracting: (19<=haveA2andB)
states: 0
abstracting: (Clients<=resB)
states: 120
abstracting: (haveAandB<=haveAandB)
states: 7,006 (3)
abstracting: (haveA<=0)
states: 1,715 (3)
abstracting: (Clients<=haveA2andB)
states: 65
abstracting: (17<=Clients)
states: 56
abstracting: (14<=resB)
states: 0
-> the formula is TRUE

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

MC time: 0m 0.005sec

checking: AG [[[[resB<=13 | ~ [haveA2<=15]] & ~ [[~ [[[haveA2andB<=haveB & 12<=haveA2] | [haveA2andB<=18 | resB<=resA]]] & ~ [[[[resB<=haveB | haveA<=16] | ~ [resA<=haveA2]] | [haveA<=resA & [haveA<=14 | Clients<=18]]]]]]] | 15<=resA]]
normalized: ~ [E [true U ~ [[[~ [[~ [[[[haveA<=14 | Clients<=18] & haveA<=resA] | [~ [resA<=haveA2] | [resB<=haveB | haveA<=16]]]] & ~ [[[haveA2andB<=18 | resB<=resA] | [haveA2andB<=haveB & 12<=haveA2]]]]] & [~ [haveA2<=15] | resB<=13]] | 15<=resA]]]]

abstracting: (15<=resA)
states: 0
abstracting: (resB<=13)
states: 7,006 (3)
abstracting: (haveA2<=15)
states: 7,006 (3)
abstracting: (12<=haveA2)
states: 0
abstracting: (haveA2andB<=haveB)
states: 5,298 (3)
abstracting: (resB<=resA)
states: 3,002 (3)
abstracting: (haveA2andB<=18)
states: 7,006 (3)
abstracting: (haveA<=16)
states: 7,006 (3)
abstracting: (resB<=haveB)
states: 3,758 (3)
abstracting: (resA<=haveA2)
states: 3,968 (3)
abstracting: (haveA<=resA)
states: 3,968 (3)
abstracting: (Clients<=18)
states: 7,000 (3)
abstracting: (haveA<=14)
states: 7,006 (3)
-> the formula is TRUE

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

MC time: 0m 0.007sec

checking: AG [[haveB<=1 | [~ [[haveAandB<=14 & [[[~ [[resA<=haveB & Clients<=haveA2andB]] | [haveA2<=6 & 2<=haveA2andB]] & [~ [16<=haveB] & haveA<=haveB]] & ~ [[~ [8<=haveB] | [haveAandB<=4 | [17<=Clients & 2<=haveA2andB]]]]]]] | ~ [[~ [haveA2<=haveA] & haveB<=18]]]]]
normalized: ~ [E [true U ~ [[[~ [[~ [haveA2<=haveA] & haveB<=18]] | ~ [[[~ [[[[17<=Clients & 2<=haveA2andB] | haveAandB<=4] | ~ [8<=haveB]]] & [[~ [16<=haveB] & haveA<=haveB] & [[haveA2<=6 & 2<=haveA2andB] | ~ [[resA<=haveB & Clients<=haveA2andB]]]]] & haveAandB<=14]]] | haveB<=1]]]]

abstracting: (haveB<=1)
states: 1,991 (3)
abstracting: (haveAandB<=14)
states: 7,006 (3)
abstracting: (Clients<=haveA2andB)
states: 65
abstracting: (resA<=haveB)
states: 5,004 (3)
abstracting: (2<=haveA2andB)
states: 2,871 (3)
abstracting: (haveA2<=6)
states: 6,664 (3)
abstracting: (haveA<=haveB)
states: 5,004 (3)
abstracting: (16<=haveB)
states: 0
abstracting: (8<=haveB)
states: 552
abstracting: (haveAandB<=4)
states: 6,502 (3)
abstracting: (2<=haveA2andB)
states: 2,871 (3)
abstracting: (17<=Clients)
states: 56
abstracting: (haveB<=18)
states: 7,006 (3)
abstracting: (haveA2<=haveA)
states: 3,969 (3)
-> the formula is TRUE

FORMULA TwoPhaseLocking-PT-nC00020vD-ReachabilityCardinality-11 TRUE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.004sec

checking: AG [[[~ [18<=haveAandB] | [20<=haveA2andB & [[haveA<=resA & 2<=Clients] & ~ [resB<=haveA2]]]] | [~ [[[[[haveAandB<=3 & ~ [2<=haveB]] & [11<=haveA2 | ~ [haveAandB<=9]]] & ~ [[12<=haveA2andB & [[19<=haveA2 & haveA2<=17] | haveAandB<=haveA2]]]] | [~ [resA<=3] | ~ [haveA2andB<=haveA2]]]] | ~ [haveAandB<=11]]]]
normalized: ~ [E [true U ~ [[[~ [haveAandB<=11] | ~ [[[~ [haveA2andB<=haveA2] | ~ [resA<=3]] | [~ [[[[19<=haveA2 & haveA2<=17] | haveAandB<=haveA2] & 12<=haveA2andB]] & [[~ [haveAandB<=9] | 11<=haveA2] & [~ [2<=haveB] & haveAandB<=3]]]]]] | [[[~ [resB<=haveA2] & [haveA<=resA & 2<=Clients]] & 20<=haveA2andB] | ~ [18<=haveAandB]]]]]]

abstracting: (18<=haveAandB)
states: 0
abstracting: (20<=haveA2andB)
states: 0
abstracting: (2<=Clients)
states: 6,955 (3)
abstracting: (haveA<=resA)
states: 3,968 (3)
abstracting: (resB<=haveA2)
states: 3,002 (3)
abstracting: (haveAandB<=3)
states: 6,040 (3)
abstracting: (2<=haveB)
states: 5,015 (3)
abstracting: (11<=haveA2)
states: 0
abstracting: (haveAandB<=9)
states: 7,005 (3)
abstracting: (12<=haveA2andB)
states: 0
abstracting: (haveAandB<=haveA2)
states: 4,696 (3)
abstracting: (haveA2<=17)
states: 7,006 (3)
abstracting: (19<=haveA2)
states: 0
abstracting: (resA<=3)
states: 5,200 (3)
abstracting: (haveA2andB<=haveA2)
states: 4,696 (3)
abstracting: (haveAandB<=11)
states: 7,006 (3)
-> the formula is TRUE

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

MC time: 0m 0.005sec

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

abstracting: (haveB<=4)
states: 4,683 (3)
abstracting: (haveA2<=haveAandB)
states: 3,486 (3)
abstracting: (haveB<=resB)
states: 3,759 (3)
abstracting: (haveAandB<=8)
states: 6,998 (3)
abstracting: (haveA2<=resA)
states: 3,969 (3)
abstracting: (10<=Clients)
states: 3,003 (3)
abstracting: (Clients<=2)
states: 146
abstracting: (resB<=resA)
states: 3,002 (3)
abstracting: (haveA<=13)
states: 7,006 (3)
abstracting: (haveAandB<=6)
states: 6,908 (3)
abstracting: (Clients<=haveA2)
states: 629
abstracting: (resB<=20)
states: 7,006 (3)
abstracting: (3<=haveA2andB)
states: 1,716 (3)
abstracting: (resA<=haveAandB)
states: 3,485 (3)
-> the formula is TRUE

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

MC time: 0m 0.009sec

checking: AG [[[6<=haveA2 | [~ [17<=haveB] | [~ [[[[[resB<=resA & Clients<=4] & haveB<=resB] | [~ [haveA<=haveA] & 1<=Clients]] & [20<=resB | [[resA<=Clients | haveA2<=19] & 10<=haveAandB]]]] & [[[[[haveB<=3 & 6<=haveA2andB] & [haveA<=7 & Clients<=Clients]] | [~ [haveB<=20] & [haveA<=17 | haveA2andB<=15]]] | haveB<=18] | 7<=haveB]]]] | 17<=haveA]]
normalized: ~ [E [true U ~ [[17<=haveA | [6<=haveA2 | [[[7<=haveB | [haveB<=18 | [[[haveA<=17 | haveA2andB<=15] & ~ [haveB<=20]] | [[haveA<=7 & Clients<=Clients] & [haveB<=3 & 6<=haveA2andB]]]]] & ~ [[[20<=resB | [10<=haveAandB & [resA<=Clients | haveA2<=19]]] & [[1<=Clients & ~ [haveA<=haveA]] | [haveB<=resB & [resB<=resA & Clients<=4]]]]]] | ~ [17<=haveB]]]]]]]

abstracting: (17<=haveB)
states: 0
abstracting: (Clients<=4)
states: 601
abstracting: (resB<=resA)
states: 3,002 (3)
abstracting: (haveB<=resB)
states: 3,759 (3)
abstracting: (haveA<=haveA)
states: 7,006 (3)
abstracting: (1<=Clients)
states: 6,996 (3)
abstracting: (haveA2<=19)
states: 7,006 (3)
abstracting: (resA<=Clients)
states: 7,006 (3)
abstracting: (10<=haveAandB)
states: 1
abstracting: (20<=resB)
states: 0
abstracting: (6<=haveA2andB)
states: 238
abstracting: (haveB<=3)
states: 3,857 (3)
abstracting: (Clients<=Clients)
states: 7,006 (3)
abstracting: (haveA<=7)
states: 6,853 (3)
abstracting: (haveB<=20)
states: 7,006 (3)
abstracting: (haveA2andB<=15)
states: 7,006 (3)
abstracting: (haveA<=17)
states: 7,006 (3)
abstracting: (haveB<=18)
states: 7,006 (3)
abstracting: (7<=haveB)
states: 1,007 (3)
abstracting: (6<=haveA2)
states: 657
abstracting: (17<=haveA)
states: 0
-> the formula is TRUE

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

MC time: 0m 0.005sec

checking: AG [[haveA2andB<=haveA2andB | ~ [[[~ [[[[[6<=haveA2 & haveA2andB<=6] | haveB<=Clients] | haveAandB<=haveA2] | [haveA2<=resA & [haveA<=8 | [resB<=haveB & haveA2andB<=haveAandB]]]]] | haveA2<=resB] | [[~ [[[~ [16<=haveA2] & [haveA<=12 & resB<=haveA2andB]] | [haveA<=haveA2andB | ~ [haveB<=Clients]]]] & haveA2andB<=16] | 12<=Clients]]]]]
normalized: ~ [E [true U ~ [[haveA2andB<=haveA2andB | ~ [[[12<=Clients | [haveA2andB<=16 & ~ [[[haveA<=haveA2andB | ~ [haveB<=Clients]] | [[haveA<=12 & resB<=haveA2andB] & ~ [16<=haveA2]]]]]] | [haveA2<=resB | ~ [[[haveA2<=resA & [haveA<=8 | [resB<=haveB & haveA2andB<=haveAandB]]] | [haveAandB<=haveA2 | [haveB<=Clients | [6<=haveA2 & haveA2andB<=6]]]]]]]]]]]]

abstracting: (haveA2andB<=6)
states: 6,908 (3)
abstracting: (6<=haveA2)
states: 657
abstracting: (haveB<=Clients)
states: 5,985 (3)
abstracting: (haveAandB<=haveA2)
states: 4,696 (3)
abstracting: (haveA2andB<=haveAandB)
states: 4,213 (3)
abstracting: (resB<=haveB)
states: 3,758 (3)
abstracting: (haveA<=8)
states: 6,953 (3)
abstracting: (haveA2<=resA)
states: 3,969 (3)
abstracting: (haveA2<=resB)
states: 5,005 (3)
abstracting: (16<=haveA2)
states: 0
abstracting: (resB<=haveA2andB)
states: 2,568 (3)
abstracting: (haveA<=12)
states: 7,006 (3)
abstracting: (haveB<=Clients)
states: 5,985 (3)
abstracting: (haveA<=haveA2andB)
states: 3,485 (3)
abstracting: (haveA2andB<=16)
states: 7,006 (3)
abstracting: (12<=Clients)
states: 1,287 (3)
abstracting: (haveA2andB<=haveA2andB)
states: 7,006 (3)
-> the formula is TRUE

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

MC time: 0m 0.006sec

checking: AG [[[[~ [haveA2<=resB] | ~ [[~ [haveA<=haveB] | [17<=resB & [~ [16<=resB] | [17<=haveA2 | haveA<=haveA2andB]]]]]] & ~ [haveAandB<=haveAandB]] | ~ [[[[Clients<=haveA2 | 2<=Clients] & ~ [10<=Clients]] & ~ [[[resB<=16 & [resB<=10 | ~ [[16<=Clients & 13<=haveAandB]]]] | [[[haveA2<=haveB & 14<=haveA2] & ~ [Clients<=haveB]] & [[[haveA<=haveA2andB | haveA<=17] | 4<=haveB] & 4<=Clients]]]]]]]]
normalized: ~ [E [true U ~ [[~ [[~ [[[[4<=Clients & [4<=haveB | [haveA<=haveA2andB | haveA<=17]]] & [~ [Clients<=haveB] & [haveA2<=haveB & 14<=haveA2]]] | [resB<=16 & [resB<=10 | ~ [[16<=Clients & 13<=haveAandB]]]]]] & [~ [10<=Clients] & [Clients<=haveA2 | 2<=Clients]]]] | [~ [haveAandB<=haveAandB] & [~ [[[17<=resB & [[17<=haveA2 | haveA<=haveA2andB] | ~ [16<=resB]]] | ~ [haveA<=haveB]]] | ~ [haveA2<=resB]]]]]]]

abstracting: (haveA2<=resB)
states: 5,005 (3)
abstracting: (haveA<=haveB)
states: 5,004 (3)
abstracting: (16<=resB)
states: 0
abstracting: (haveA<=haveA2andB)
states: 3,485 (3)
abstracting: (17<=haveA2)
states: 0
abstracting: (17<=resB)
states: 0
abstracting: (haveAandB<=haveAandB)
states: 7,006 (3)
abstracting: (2<=Clients)
states: 6,955 (3)
abstracting: (Clients<=haveA2)
states: 629
abstracting: (10<=Clients)
states: 3,003 (3)
abstracting: (13<=haveAandB)
states: 0
abstracting: (16<=Clients)
states: 126
abstracting: (resB<=10)
states: 7,006 (3)
abstracting: (resB<=16)
states: 7,006 (3)
abstracting: (14<=haveA2)
states: 0
abstracting: (haveA2<=haveB)
states: 5,004 (3)
abstracting: (Clients<=haveB)
states: 1,357 (3)
abstracting: (haveA<=17)
states: 7,006 (3)
abstracting: (haveA<=haveA2andB)
states: 3,485 (3)
abstracting: (4<=haveB)
states: 3,149 (3)
abstracting: (4<=Clients)
states: 6,685 (3)
-> the formula is TRUE

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

MC time: 0m 0.005sec

checking: AG [[[haveB<=6 & ~ [16<=resA]] | ~ [[~ [[4<=resA & [~ [haveAandB<=3] | ~ [19<=haveA2andB]]]] & [resB<=resA & [[~ [[~ [20<=haveA2andB] & [resB<=haveA | 17<=haveA]]] & [[[14<=resA & haveB<=haveB] & ~ [haveB<=20]] & [~ [haveAandB<=haveA2] & haveB<=10]]] & [~ [[3<=haveA2andB & [2<=haveA & 9<=haveB]]] | [[[resB<=haveB & resB<=resA] | [resA<=haveA & resB<=haveA]] & haveAandB<=11]]]]]]]]
normalized: ~ [E [true U ~ [[~ [[[resB<=resA & [[[haveAandB<=11 & [[resA<=haveA & resB<=haveA] | [resB<=haveB & resB<=resA]]] | ~ [[3<=haveA2andB & [2<=haveA & 9<=haveB]]]] & [[[haveB<=10 & ~ [haveAandB<=haveA2]] & [~ [haveB<=20] & [14<=resA & haveB<=haveB]]] & ~ [[[resB<=haveA | 17<=haveA] & ~ [20<=haveA2andB]]]]]] & ~ [[4<=resA & [~ [19<=haveA2andB] | ~ [haveAandB<=3]]]]]] | [haveB<=6 & ~ [16<=resA]]]]]]

abstracting: (16<=resA)
states: 0
abstracting: (haveB<=6)
states: 5,999 (3)
abstracting: (haveAandB<=3)
states: 6,040 (3)
abstracting: (19<=haveA2andB)
states: 0
abstracting: (4<=resA)
states: 1,806 (3)
abstracting: (20<=haveA2andB)
states: 0
abstracting: (17<=haveA)
states: 0
abstracting: (resB<=haveA)
states: 3,002 (3)
abstracting: (haveB<=haveB)
states: 7,006 (3)
abstracting: (14<=resA)
states: 0
abstracting: (haveB<=20)
states: 7,006 (3)
abstracting: (haveAandB<=haveA2)
states: 4,696 (3)
abstracting: (haveB<=10)
states: 7,006 (3)
abstracting: (9<=haveB)
states: 241
abstracting: (2<=haveA)
states: 3,861 (3)
abstracting: (3<=haveA2andB)
states: 1,716 (3)
abstracting: (resB<=resA)
states: 3,002 (3)
abstracting: (resB<=haveB)
states: 3,758 (3)
abstracting: (resB<=haveA)
states: 3,002 (3)
abstracting: (resA<=haveA)
states: 3,968 (3)
abstracting: (haveAandB<=11)
states: 7,006 (3)
abstracting: (resB<=resA)
states: 3,002 (3)
-> the formula is TRUE

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

MC time: 0m 0.004sec

checking: EF [[~ [[haveA2<=14 & [[[[~ [haveB<=haveB] | [[11<=resA | resB<=haveAandB] | haveAandB<=haveA]] | [~ [[13<=resB & 16<=resA]] & ~ [12<=Clients]]] | ~ [[[~ [haveAandB<=5] | [haveAandB<=haveA | resA<=14]] & ~ [[haveAandB<=resB | haveA2<=17]]]]] & [[[~ [[resB<=18 | 16<=Clients]] | [[haveA2andB<=20 & 20<=haveAandB] | ~ [Clients<=12]]] | [~ [[19<=Clients & 11<=haveA2]] & [[12<=Clients | haveAandB<=resA] | [Clients<=haveA & haveA2<=haveAandB]]]] | [~ [[~ [8<=haveA2andB] & 5<=resA]] & ~ [[haveA2andB<=Clients | resA<=haveA2andB]]]]]]] & ~ [[[resA<=15 | haveA2andB<=9] | [[~ [[~ [14<=haveAandB] | [haveA<=haveA2andB & 18<=haveA]]] | [[[[15<=haveB | Clients<=resB] & [4<=haveA2andB & 2<=haveA]] & [[haveA2andB<=haveB | Clients<=resB] | ~ [haveA2<=11]]] & [[[Clients<=14 | haveB<=haveA] | haveAandB<=resB] & ~ [13<=resB]]]] & 1<=resA]]]]]
normalized: E [true U [~ [[[1<=resA & [[[~ [13<=resB] & [haveAandB<=resB | [Clients<=14 | haveB<=haveA]]] & [[~ [haveA2<=11] | [haveA2andB<=haveB | Clients<=resB]] & [[4<=haveA2andB & 2<=haveA] & [15<=haveB | Clients<=resB]]]] | ~ [[[haveA<=haveA2andB & 18<=haveA] | ~ [14<=haveAandB]]]]] | [resA<=15 | haveA2andB<=9]]] & ~ [[haveA2<=14 & [[[~ [[haveA2andB<=Clients | resA<=haveA2andB]] & ~ [[5<=resA & ~ [8<=haveA2andB]]]] | [[[[Clients<=haveA & haveA2<=haveAandB] | [12<=Clients | haveAandB<=resA]] & ~ [[19<=Clients & 11<=haveA2]]] | [[~ [Clients<=12] | [haveA2andB<=20 & 20<=haveAandB]] | ~ [[resB<=18 | 16<=Clients]]]]] & [~ [[~ [[haveAandB<=resB | haveA2<=17]] & [[haveAandB<=haveA | resA<=14] | ~ [haveAandB<=5]]]] | [[~ [12<=Clients] & ~ [[13<=resB & 16<=resA]]] | [[haveAandB<=haveA | [11<=resA | resB<=haveAandB]] | ~ [haveB<=haveB]]]]]]]]]

abstracting: (haveB<=haveB)
states: 7,006 (3)
abstracting: (resB<=haveAandB)
states: 2,568 (3)
abstracting: (11<=resA)
states: 0
abstracting: (haveAandB<=haveA)
states: 4,696 (3)
abstracting: (16<=resA)
states: 0
abstracting: (13<=resB)
states: 0
abstracting: (12<=Clients)
states: 1,287 (3)
abstracting: (haveAandB<=5)
states: 6,768 (3)
abstracting: (resA<=14)
states: 7,006 (3)
abstracting: (haveAandB<=haveA)
states: 4,696 (3)
abstracting: (haveA2<=17)
states: 7,006 (3)
abstracting: (haveAandB<=resB)
states: 5,298 (3)
abstracting: (16<=Clients)
states: 126
abstracting: (resB<=18)
states: 7,006 (3)
abstracting: (20<=haveAandB)
states: 0
abstracting: (haveA2andB<=20)
states: 7,006 (3)
abstracting: (Clients<=12)
states: 6,214 (3)
abstracting: (11<=haveA2)
states: 0
abstracting: (19<=Clients)
states: 6
abstracting: (haveAandB<=resA)
states: 4,696 (3)
abstracting: (12<=Clients)
states: 1,287 (3)
abstracting: (haveA2<=haveAandB)
states: 3,486 (3)
abstracting: (Clients<=haveA)
states: 629
abstracting: (8<=haveA2andB)
states: 33
abstracting: (5<=resA)
states: 1,134 (3)
abstracting: (resA<=haveA2andB)
states: 3,485 (3)
abstracting: (haveA2andB<=Clients)
states: 7,006 (3)
abstracting: (haveA2<=14)
states: 7,006 (3)
abstracting: (haveA2andB<=9)
states: 7,005 (3)
abstracting: (resA<=15)
states: 7,006 (3)
abstracting: (14<=haveAandB)
states: 0
abstracting: (18<=haveA)
states: 0
abstracting: (haveA<=haveA2andB)
states: 3,485 (3)
abstracting: (Clients<=resB)
states: 120
abstracting: (15<=haveB)
states: 0
abstracting: (2<=haveA)
states: 3,861 (3)
abstracting: (4<=haveA2andB)
states: 966
abstracting: (Clients<=resB)
states: 120
abstracting: (haveA2andB<=haveB)
states: 5,298 (3)
abstracting: (haveA2<=11)
states: 7,006 (3)
abstracting: (haveB<=haveA)
states: 3,003 (3)
abstracting: (Clients<=14)
states: 6,754 (3)
abstracting: (haveAandB<=resB)
states: 5,298 (3)
abstracting: (13<=resB)
states: 0
abstracting: (1<=resA)
states: 5,291 (3)
-> the formula is FALSE

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

MC time: 0m 0.013sec

totally nodes used: 16593 (1.7e+04)
number of garbage collections: 0
fire ops cache: hits/miss/sum: 34595 13845 48440
used/not used/entry size/cache size: 15294 67093570 16 1024MB
basic ops cache: hits/miss/sum: 118727 125421 244148
used/not used/entry size/cache size: 160889 16616327 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: 26199 9972 36171
used/not used/entry size/cache size: 9972 8378636 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 67093947
1 14268
2 464
3 92
4 29
5 3
6 3
7 2
8 5
9 1
>= 10 50

Total processing time: 0m 4.462sec


BK_STOP 1679339157566

--------------------
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:268 (44), effective:87 (14)

initing FirstDep: 0m 0.000sec

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-nC00020vD"
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-nC00020vD, 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-167912709100806"
echo "====================================================================="
echo
echo "--------------------"
echo "preparation of the directory to be used:"

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