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

--------------------
preparation of the directory to be used:
/home/mcc/execution
total 464K
-rw-r--r-- 1 mcc users 7.6K Feb 25 17:50 CTLCardinality.txt
-rw-r--r-- 1 mcc users 77K Feb 25 17:50 CTLCardinality.xml
-rw-r--r-- 1 mcc users 5.1K Feb 25 17:48 CTLFireability.txt
-rw-r--r-- 1 mcc users 42K Feb 25 17:48 CTLFireability.xml
-rw-r--r-- 1 mcc users 3.7K Feb 25 17:23 LTLCardinality.txt
-rw-r--r-- 1 mcc users 22K Feb 25 17:23 LTLCardinality.xml
-rw-r--r-- 1 mcc users 2.5K 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:51 ReachabilityCardinality.txt
-rw-r--r-- 1 mcc users 128K Feb 25 17:51 ReachabilityCardinality.xml
-rw-r--r-- 1 mcc users 11K Feb 25 17:50 ReachabilityFireability.txt
-rw-r--r-- 1 mcc users 88K Feb 25 17:50 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-nC00100vN-ReachabilityCardinality-00
FORMULA_NAME TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-01
FORMULA_NAME TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-02
FORMULA_NAME TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-03
FORMULA_NAME TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-04
FORMULA_NAME TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-05
FORMULA_NAME TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-06
FORMULA_NAME TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-07
FORMULA_NAME TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-08
FORMULA_NAME TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-09
FORMULA_NAME TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-10
FORMULA_NAME TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-11
FORMULA_NAME TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-12
FORMULA_NAME TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-13
FORMULA_NAME TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-14
FORMULA_NAME TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-15

=== Now, execution of the tool begins

BK_START 1679339664809

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-nC00100vN
Applying reductions before tool marcie
Invoking reducer
Running Version 202303021504
[2023-03-20 19:14:26] [INFO ] Running its-tools with arguments : [-pnfolder, /home/mcc/execution, -examination, ReachabilityCardinality, -timeout, 360, -rebuildPNML]
[2023-03-20 19:14:26] [INFO ] Parsing pnml file : /home/mcc/execution/model.pnml
[2023-03-20 19:14:26] [INFO ] Load time of PNML (sax parser for PT used): 16 ms
[2023-03-20 19:14:26] [INFO ] Transformed 8 places.
[2023-03-20 19:14:26] [INFO ] Transformed 6 transitions.
[2023-03-20 19:14:26] [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 16 ms.
Working with output stream class java.io.PrintStream
Incomplete random walk after 10001 steps, including 2 resets, run finished after 112 ms. (steps per millisecond=89 ) properties (out of 16) seen :12
FORMULA TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-15 FALSE TECHNIQUES TOPOLOGICAL RANDOM_WALK
FORMULA TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-13 FALSE TECHNIQUES TOPOLOGICAL RANDOM_WALK
FORMULA TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-12 TRUE TECHNIQUES TOPOLOGICAL RANDOM_WALK
FORMULA TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-10 TRUE TECHNIQUES TOPOLOGICAL RANDOM_WALK
FORMULA TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-09 FALSE TECHNIQUES TOPOLOGICAL RANDOM_WALK
FORMULA TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-08 FALSE TECHNIQUES TOPOLOGICAL RANDOM_WALK
FORMULA TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-07 TRUE TECHNIQUES TOPOLOGICAL RANDOM_WALK
FORMULA TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-06 TRUE TECHNIQUES TOPOLOGICAL RANDOM_WALK
FORMULA TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-05 TRUE TECHNIQUES TOPOLOGICAL RANDOM_WALK
FORMULA TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-02 FALSE TECHNIQUES TOPOLOGICAL RANDOM_WALK
FORMULA TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-01 TRUE TECHNIQUES TOPOLOGICAL RANDOM_WALK
FORMULA TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-00 TRUE TECHNIQUES TOPOLOGICAL RANDOM_WALK
Incomplete Best-First random walk after 10001 steps, including 2 resets, run finished after 68 ms. (steps per millisecond=147 ) properties (out of 4) seen :0
Incomplete Best-First random walk after 10001 steps, including 2 resets, run finished after 73 ms. (steps per millisecond=137 ) properties (out of 4) seen :0
Incomplete Best-First random walk after 10000 steps, including 2 resets, run finished after 117 ms. (steps per millisecond=85 ) properties (out of 4) seen :0
Incomplete Best-First random walk after 10001 steps, including 2 resets, run finished after 58 ms. (steps per millisecond=172 ) properties (out of 4) seen :0
Running SMT prover for 4 properties.
// Phase 1: matrix 6 rows 8 cols
[2023-03-20 19:14:26] [INFO ] Computed 3 place invariants in 3 ms
[2023-03-20 19:14:26] [INFO ] [Real]Absence check using 3 positive place invariants in 1 ms returned sat
[2023-03-20 19:14:26] [INFO ] After 134ms SMT Verify possible using all constraints in real domain returned unsat :2 sat :0 real:2
[2023-03-20 19:14:27] [INFO ] [Nat]Absence check using 3 positive place invariants in 1 ms returned sat
[2023-03-20 19:14:27] [INFO ] After 29ms SMT Verify possible using all constraints in natural domain returned unsat :4 sat :0
FORMULA TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-14 TRUE TECHNIQUES STRUCTURAL_REDUCTION TOPOLOGICAL SAT_SMT
FORMULA TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-11 TRUE TECHNIQUES STRUCTURAL_REDUCTION TOPOLOGICAL SAT_SMT
FORMULA TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-04 TRUE TECHNIQUES STRUCTURAL_REDUCTION TOPOLOGICAL SAT_SMT
FORMULA TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-03 FALSE TECHNIQUES STRUCTURAL_REDUCTION TOPOLOGICAL SAT_SMT
Fused 4 Parikh solutions to 0 different solutions.
Parikh walk visited 0 properties in 0 ms.
All properties solved without resorting to model-checking.
Total runtime 765 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_nC00100vN
(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.762sec


RS generation: 0m 2.245sec


-> reachability set: #nodes 77010 (7.7e+04) #states 10,119,981 (7)



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

checking: EF [11<=haveB]
normalized: E [true U 11<=haveB]

abstracting: (11<=haveB)
states: 6,664,089 (6)
-> the formula is TRUE

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

MC time: 0m 0.368sec

checking: EF [~ [[50<=Clients | haveA2andB<=79]]]
normalized: E [true U ~ [[50<=Clients | haveA2andB<=79]]]

abstracting: (haveA2andB<=79)
states: 10,119,981 (7)
abstracting: (50<=Clients)
states: 3,478,761 (6)
-> the formula is FALSE

FORMULA TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-03 FALSE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 0.066sec

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

abstracting: (resB<=Clients)
states: 10,117,380 (7)
-> the formula is FALSE

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

MC time: 0m 4.816sec

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

abstracting: (92<=haveA)
states: 0
abstracting: (haveA<=61)
states: 10,119,981 (7)
-> the formula is TRUE

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

MC time: 0m 0.120sec

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

abstracting: (haveAandB<=resB)
states: 7,333,041 (6)
abstracting: (resA<=49)
states: 10,119,929 (7)
-> the formula is TRUE

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

MC time: 0m 1.665sec

checking: AG [~ [[[resB<=29 | ~ [89<=resB]] & 90<=haveA2]]]
normalized: ~ [E [true U [90<=haveA2 & [resB<=29 | ~ [89<=resB]]]]]

abstracting: (89<=resB)
states: 0
abstracting: (resB<=29)
states: 8,392,497 (6)
abstracting: (90<=haveA2)
states: 0
-> the formula is TRUE

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

MC time: 0m 0.171sec

checking: AG [[haveA2andB<=56 & [[[~ [58<=resB] & ~ [[[~ [81<=haveA] | 16<=haveA2] & [~ [resA<=Clients] | [~ [34<=resB] | ~ [haveB<=haveB]]]]]] | haveA2andB<=haveA2] | 5<=Clients]]]
normalized: ~ [E [true U ~ [[haveA2andB<=56 & [5<=Clients | [haveA2andB<=haveA2 | [~ [[[[~ [haveB<=haveB] | ~ [34<=resB]] | ~ [resA<=Clients]] & [16<=haveA2 | ~ [81<=haveA]]]] & ~ [58<=resB]]]]]]]]

abstracting: (58<=resB)
states: 0
abstracting: (81<=haveA)
states: 0
abstracting: (16<=haveA2)
states: 2,834,461 (6)
abstracting: (resA<=Clients)
states: 10,118,706 (7)
abstracting: (34<=resB)
states: 1,063,962 (6)
abstracting: (haveB<=haveB)
states: 10,119,981 (7)
abstracting: (haveA2andB<=haveA2)
states: 6,089,331 (6)
abstracting: (5<=Clients)
states: 10,113,984 (7)
abstracting: (haveA2andB<=56)
states: 10,119,981 (7)
-> the formula is FALSE

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

MC time: 0m 1.649sec

checking: AG [[[~ [haveA<=resB] | [[resA<=resA & [[2<=haveAandB | [resB<=resA & ~ [haveA2andB<=haveA2]]] | haveA2<=73]] | haveA2andB<=Clients]] | 14<=Clients]]
normalized: ~ [E [true U ~ [[14<=Clients | [[haveA2andB<=Clients | [resA<=resA & [haveA2<=73 | [2<=haveAandB | [resB<=resA & ~ [haveA2andB<=haveA2]]]]]] | ~ [haveA<=resB]]]]]]

abstracting: (haveA<=resB)
states: 6,957,521 (6)
abstracting: (haveA2andB<=haveA2)
states: 6,089,331 (6)
abstracting: (resB<=resA)
states: 3,478,710 (6)
abstracting: (2<=haveAandB)
states: 8,338,330 (6)
abstracting: (haveA2<=73)
states: 10,119,981 (7)
abstracting: (resA<=resA)
states: 10,119,981 (7)
abstracting: (haveA2andB<=Clients)
states: 10,118,706 (7)
abstracting: (14<=Clients)
states: 9,989,676 (6)
-> the formula is TRUE

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

MC time: 0m 1.813sec

checking: AG [[~ [haveA2<=99] | ~ [[[resA<=11 & ~ [[haveAandB<=5 & [resB<=1 | [34<=resB | 44<=haveB]]]]] & [[[~ [[~ [52<=haveAandB] & ~ [haveA2andB<=32]]] & Clients<=77] | [[~ [[haveAandB<=56 | 59<=haveA2]] & ~ [[52<=resB & 9<=resA]]] | [[[haveB<=78 & resB<=57] & resA<=66] & haveB<=69]]] & [haveB<=resA | Clients<=62]]]]]]
normalized: ~ [E [true U ~ [[~ [[[[haveB<=resA | Clients<=62] & [[[haveB<=69 & [resA<=66 & [haveB<=78 & resB<=57]]] | [~ [[52<=resB & 9<=resA]] & ~ [[haveAandB<=56 | 59<=haveA2]]]] | [Clients<=77 & ~ [[~ [haveA2andB<=32] & ~ [52<=haveAandB]]]]]] & [resA<=11 & ~ [[haveAandB<=5 & [resB<=1 | [34<=resB | 44<=haveB]]]]]]] | ~ [haveA2<=99]]]]]

abstracting: (haveA2<=99)
states: 10,119,981 (7)
abstracting: (44<=haveB)
states: 138,405 (5)
abstracting: (34<=resB)
states: 1,063,962 (6)
abstracting: (resB<=1)
states: 632,451 (5)
abstracting: (haveAandB<=5)
states: 4,593,909 (6)
abstracting: (resA<=11)
states: 6,000,957 (6)
abstracting: (52<=haveAandB)
states: 0
abstracting: (haveA2andB<=32)
states: 10,046,964 (7)
abstracting: (Clients<=77)
states: 10,039,251 (7)
abstracting: (59<=haveA2)
states: 0
abstracting: (haveAandB<=56)
states: 10,119,981 (7)
abstracting: (9<=resA)
states: 5,304,222 (6)
abstracting: (52<=resB)
states: 0
abstracting: (resB<=57)
states: 10,119,981 (7)
abstracting: (haveB<=78)
states: 10,119,981 (7)
abstracting: (resA<=66)
states: 10,119,981 (7)
abstracting: (haveB<=69)
states: 10,119,981 (7)
abstracting: (Clients<=62)
states: 9,269,313 (6)
abstracting: (haveB<=resA)
states: 3,478,761 (6)
-> the formula is FALSE

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

MC time: 0m 1.118sec

checking: AG [~ [[~ [[[haveB<=haveA2andB | haveAandB<=95] | [~ [76<=haveA] | ~ [[[haveA2andB<=resA | 46<=Clients] & ~ [haveA<=Clients]]]]]] | [[resB<=38 | [[[[haveA2andB<=haveB | resB<=49] | [64<=haveAandB & 10<=resA]] & [~ [resA<=haveB] & ~ [14<=resB]]] & [~ [[47<=resA | haveA2andB<=48]] | ~ [[Clients<=30 & 64<=resA]]]]] & [13<=haveA2 & Clients<=haveAandB]]]]]
normalized: ~ [E [true U [[[13<=haveA2 & Clients<=haveAandB] & [resB<=38 | [[~ [[Clients<=30 & 64<=resA]] | ~ [[47<=resA | haveA2andB<=48]]] & [[~ [14<=resB] & ~ [resA<=haveB]] & [[64<=haveAandB & 10<=resA] | [haveA2andB<=haveB | resB<=49]]]]]] | ~ [[[~ [[~ [haveA<=Clients] & [haveA2andB<=resA | 46<=Clients]]] | ~ [76<=haveA]] | [haveB<=haveA2andB | haveAandB<=95]]]]]]

abstracting: (haveAandB<=95)
states: 10,119,981 (7)
abstracting: (haveB<=haveA2andB)
states: 3,065,166 (6)
abstracting: (76<=haveA)
states: 0
abstracting: (46<=Clients)
states: 4,731,012 (6)
abstracting: (haveA2andB<=resA)
states: 6,089,331 (6)
abstracting: (haveA<=Clients)
states: 9,621,261 (6)
abstracting: (resB<=49)
states: 10,114,779 (7)
abstracting: (haveA2andB<=haveB)
states: 7,333,041 (6)
abstracting: (10<=resA)
states: 4,887,036 (6)
abstracting: (64<=haveAandB)
states: 0
abstracting: (resA<=haveB)
states: 6,957,471 (6)
abstracting: (14<=resB)
states: 5,753,124 (6)
abstracting: (haveA2andB<=48)
states: 10,119,968 (7)
abstracting: (47<=resA)
states: 1,778 (3)
abstracting: (64<=resA)
states: 0
abstracting: (Clients<=30)
states: 1,696,413 (6)
abstracting: (resB<=38)
states: 9,646,872 (6)
abstracting: (Clients<=haveAandB)
states: 5,151 (3)
abstracting: (13<=haveA2)
states: 3,767,206 (6)
-> the formula is FALSE

FORMULA TwoPhaseLocking-PT-nC00100vN-ReachabilityCardinality-09 FALSE TECHNIQUES SEQUENTIAL_PROCESSING DECISION_DIAGRAMS UNFOLDING_TO_PT

MC time: 0m 3.382sec

checking: EF [~ [[haveA2<=35 | [[[resA<=haveAandB & ~ [[resB<=haveA | haveA<=14]]] | [88<=haveA2andB | [haveA2andB<=Clients & [[[27<=resB & 79<=haveA2andB] & haveB<=haveB] & [[70<=resB | resB<=haveA] & [haveA2<=50 & resA<=7]]]]]] | [[~ [haveAandB<=15] | ~ [[[haveA2<=haveAandB | [resA<=resA | 48<=haveA]] & [haveA2<=70 | 76<=resB]]]] & Clients<=44]]]]]
normalized: E [true U ~ [[haveA2<=35 | [[Clients<=44 & [~ [[[haveA2<=70 | 76<=resB] & [haveA2<=haveAandB | [resA<=resA | 48<=haveA]]]] | ~ [haveAandB<=15]]] | [[88<=haveA2andB | [haveA2andB<=Clients & [[[haveA2<=50 & resA<=7] & [70<=resB | resB<=haveA]] & [haveB<=haveB & [27<=resB & 79<=haveA2andB]]]]] | [resA<=haveAandB & ~ [[resB<=haveA | haveA<=14]]]]]]]]

abstracting: (haveA<=14)
states: 6,994,479 (6)
abstracting: (resB<=haveA)
states: 3,478,710 (6)
abstracting: (resA<=haveAandB)
states: 4,432,026 (6)
abstracting: (79<=haveA2andB)
states: 0
abstracting: (27<=resB)
states: 2,330,640 (6)
abstracting: (haveB<=haveB)
states: 10,119,981 (7)
abstracting: (resB<=haveA)
states: 3,478,710 (6)
abstracting: (70<=resB)
states: 0
abstracting: (resA<=7)
states: 4,375,869 (6)
abstracting: (haveA2<=50)
states: 10,119,981 (7)
abstracting: (haveA2andB<=Clients)
states: 10,118,706 (7)
abstracting: (88<=haveA2andB)
states: 0
abstracting: (haveAandB<=15)
states: 8,466,525 (6)
abstracting: (48<=haveA)
states: 765
abstracting: (resA<=resA)
states: 10,119,981 (7)
abstracting: (haveA2<=haveAandB)
states: 4,432,076 (6)
abstracting: (76<=resB)
states: 0
abstracting: (haveA2<=70)
states: 10,119,981 (7)
abstracting: (Clients<=44)
states: 5,084,973 (6)
abstracting: (haveA2<=35)
states: 9,978,012 (6)
-> the formula is TRUE

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

MC time: 0m 4.908sec

checking: EF [[[resA<=76 | [~ [[~ [haveA2<=58] & resB<=22]] & [[[~ [resB<=85] & 97<=haveA2] & [[~ [73<=haveB] | ~ [[haveA<=haveA2 & haveA2<=haveA2andB]]] & [~ [[89<=haveA & 35<=haveA]] & ~ [[87<=haveAandB | haveA2<=14]]]]] | [[38<=Clients | [[15<=haveA2andB & [haveB<=haveA2 & Clients<=Clients]] & Clients<=haveA]] | [[[~ [resA<=haveA] & ~ [73<=resA]] | haveA2andB<=24] | [haveA<=38 & [~ [haveB<=Clients] & [haveA2andB<=Clients & 96<=haveB]]]]]]]] & resB<=23]]
normalized: E [true U [resB<=23 & [resA<=76 | [[[[[haveA<=38 & [[haveA2andB<=Clients & 96<=haveB] & ~ [haveB<=Clients]]] | [haveA2andB<=24 | [~ [73<=resA] & ~ [resA<=haveA]]]] | [38<=Clients | [Clients<=haveA & [15<=haveA2andB & [haveB<=haveA2 & Clients<=Clients]]]]] | [[[~ [[87<=haveAandB | haveA2<=14]] & ~ [[89<=haveA & 35<=haveA]]] & [~ [[haveA<=haveA2 & haveA2<=haveA2andB]] | ~ [73<=haveB]]] & [97<=haveA2 & ~ [resB<=85]]]] & ~ [[resB<=22 & ~ [haveA2<=58]]]]]]]

abstracting: (haveA2<=58)
states: 10,119,981 (7)
abstracting: (resB<=22)
states: 6,859,308 (6)
abstracting: (resB<=85)
states: 10,119,981 (7)
abstracting: (97<=haveA2)
states: 0
abstracting: (73<=haveB)
states: 0
abstracting: (haveA2<=haveA2andB)
states: 4,432,076 (6)
abstracting: (haveA<=haveA2)
states: 5,221,216 (6)
abstracting: (35<=haveA)
states: 178,280 (5)
abstracting: (89<=haveA)
states: 0
abstracting: (haveA2<=14)
states: 6,994,479 (6)
abstracting: (87<=haveAandB)
states: 0
abstracting: (Clients<=Clients)
states: 10,119,981 (7)
abstracting: (haveB<=haveA2)
states: 3,478,761 (6)
abstracting: (15<=haveA2andB)
states: 1,891,773 (6)
abstracting: (Clients<=haveA)
states: 546,221 (5)
abstracting: (38<=Clients)
states: 6,963,606 (6)
abstracting: (resA<=haveA)
states: 5,221,191 (6)
abstracting: (73<=resA)
states: 0
abstracting: (haveA2andB<=24)
states: 9,716,214 (6)
abstracting: (haveB<=Clients)
states: 8,671,221 (6)
abstracting: (96<=haveB)
states: 0
abstracting: (haveA2andB<=Clients)
states: 10,118,706 (7)
abstracting: (haveA<=38)
states: 10,055,019 (7)
abstracting: (resA<=76)
states: 10,119,981 (7)
abstracting: (resB<=23)
states: 7,104,213 (6)
-> the formula is TRUE

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

MC time: 0m 4.989sec

checking: AG [[[[[[~ [haveB<=98] & 12<=haveA2] | [[[~ [[resA<=haveA2 & 33<=haveA2]] & 92<=haveA2] & [90<=haveB & resA<=21]] & [~ [[~ [Clients<=70] | ~ [resB<=Clients]]] & [[[haveB<=resB & haveA<=haveB] & [haveA<=11 | resA<=resA]] | [~ [71<=resB] & 87<=haveA2]]]]] | [haveA2<=34 & resA<=54]] & [[[~ [[~ [[haveA2andB<=2 & Clients<=haveA2]] & ~ [78<=Clients]]] & ~ [[~ [55<=haveA] & [[haveA2andB<=resA | 32<=haveA2andB] & haveA<=Clients]]]] & ~ [[resA<=4 & [~ [77<=haveB] | [[59<=Clients & 60<=haveA] | resA<=haveB]]]]] | Clients<=resB]] | haveAandB<=39]]
normalized: ~ [E [true U ~ [[haveAandB<=39 | [[Clients<=resB | [~ [[resA<=4 & [[resA<=haveB | [59<=Clients & 60<=haveA]] | ~ [77<=haveB]]]] & [~ [[[haveA<=Clients & [haveA2andB<=resA | 32<=haveA2andB]] & ~ [55<=haveA]]] & ~ [[~ [78<=Clients] & ~ [[haveA2andB<=2 & Clients<=haveA2]]]]]]] & [[haveA2<=34 & resA<=54] | [[[[[87<=haveA2 & ~ [71<=resB]] | [[haveA<=11 | resA<=resA] & [haveB<=resB & haveA<=haveB]]] & ~ [[~ [resB<=Clients] | ~ [Clients<=70]]]] & [[90<=haveB & resA<=21] & [92<=haveA2 & ~ [[resA<=haveA2 & 33<=haveA2]]]]] | [12<=haveA2 & ~ [haveB<=98]]]]]]]]]

abstracting: (haveB<=98)
states: 10,119,981 (7)
abstracting: (12<=haveA2)
states: 4,118,985 (6)
abstracting: (33<=haveA2)
states: 270,504 (5)
abstracting: (resA<=haveA2)
states: 5,221,191 (6)
abstracting: (92<=haveA2)
states: 0
abstracting: (resA<=21)
states: 8,652,813 (6)
abstracting: (90<=haveB)
states: 0
abstracting: (Clients<=70)
states: 9,841,725 (6)
abstracting: (resB<=Clients)
states: 10,117,380 (7)
abstracting: (haveA<=haveB)
states: 6,957,471 (6)
abstracting: (haveB<=resB)
states: 5,138,991 (6)
abstracting: (resA<=resA)
states: 10,119,981 (7)
abstracting: (haveA<=11)
states: 6,000,996 (6)
abstracting: (71<=resB)
states: 0
abstracting: (87<=haveA2)
states: 0
abstracting: (resA<=54)
states: 10,119,981 (7)
abstracting: (haveA2<=34)
states: 9,941,701 (6)
abstracting: (Clients<=haveA2)
states: 546,221 (5)
abstracting: (haveA2andB<=2)
states: 2,573,001 (6)
abstracting: (78<=Clients)
states: 80,730 (4)
abstracting: (55<=haveA)
states: 0
abstracting: (32<=haveA2andB)
states: 93,632 (4)
abstracting: (haveA2andB<=resA)
states: 6,089,331 (6)
abstracting: (haveA<=Clients)
states: 9,621,261 (6)
abstracting: (77<=haveB)
states: 0
abstracting: (60<=haveA)
states: 0
abstracting: (59<=Clients)
states: 1,370,754 (6)
abstracting: (resA<=haveB)
states: 6,957,471 (6)
abstracting: (resA<=4)
states: 2,916,197 (6)
abstracting: (Clients<=resB)
states: 10,301 (4)
abstracting: (haveAandB<=39)
states: 10,111,973 (7)
-> the formula is FALSE

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

MC time: 0m 3.849sec

checking: EF [[[[~ [[12<=resB & haveAandB<=resB]] & ~ [haveB<=haveA2andB]] & haveA2<=resA] | [[~ [[[haveA<=haveB & ~ [haveAandB<=haveA2andB]] & ~ [[[~ [resA<=23] & [haveAandB<=30 & 33<=haveAandB]] & [[haveA2<=haveA | 85<=haveAandB] | 4<=Clients]]]]] & 12<=haveAandB] & [[~ [[[haveAandB<=11 | [[haveA<=53 | Clients<=haveA] | ~ [haveAandB<=haveA2]]] | resB<=37]] & [[[[[resB<=haveB & haveAandB<=32] | [resA<=38 | 87<=resB]] | haveAandB<=haveA] & [resB<=6 | [~ [haveAandB<=Clients] & ~ [resA<=resB]]]] & ~ [[resB<=57 | 98<=haveA2andB]]]] & ~ [haveB<=haveB]]]]]
normalized: E [true U [[[~ [haveB<=haveB] & [[~ [[resB<=57 | 98<=haveA2andB]] & [[resB<=6 | [~ [resA<=resB] & ~ [haveAandB<=Clients]]] & [haveAandB<=haveA | [[resA<=38 | 87<=resB] | [resB<=haveB & haveAandB<=32]]]]] & ~ [[resB<=37 | [haveAandB<=11 | [~ [haveAandB<=haveA2] | [haveA<=53 | Clients<=haveA]]]]]]] & [12<=haveAandB & ~ [[~ [[[4<=Clients | [haveA2<=haveA | 85<=haveAandB]] & [[haveAandB<=30 & 33<=haveAandB] & ~ [resA<=23]]]] & [haveA<=haveB & ~ [haveAandB<=haveA2andB]]]]]] | [haveA2<=resA & [~ [haveB<=haveA2andB] & ~ [[12<=resB & haveAandB<=resB]]]]]]

abstracting: (haveAandB<=resB)
states: 7,333,041 (6)
abstracting: (12<=resB)
states: 6,357,624 (6)
abstracting: (haveB<=haveA2andB)
states: 3,065,166 (6)
abstracting: (haveA2<=resA)
states: 5,221,241 (6)
abstracting: (haveAandB<=haveA2andB)
states: 5,300,166 (6)
abstracting: (haveA<=haveB)
states: 6,957,471 (6)
abstracting: (resA<=23)
states: 8,979,933 (6)
abstracting: (33<=haveAandB)
states: 73,017 (4)
abstracting: (haveAandB<=30)
states: 10,001,324 (7)
abstracting: (85<=haveAandB)
states: 0
abstracting: (haveA2<=haveA)
states: 5,221,216 (6)
abstracting: (4<=Clients)
states: 10,116,630 (7)
abstracting: (12<=haveAandB)
states: 2,775,864 (6)
abstracting: (Clients<=haveA)
states: 546,221 (5)
abstracting: (haveA<=53)
states: 10,119,981 (7)
abstracting: (haveAandB<=haveA2)
states: 6,089,331 (6)
abstracting: (haveAandB<=11)
states: 7,344,117 (6)
abstracting: (resB<=37)
states: 9,549,957 (6)
abstracting: (haveAandB<=32)
states: 10,046,964 (7)
abstracting: (resB<=haveB)
states: 5,138,940 (6)
abstracting: (87<=resB)
states: 0
abstracting: (resA<=38)
states: 10,055,007 (7)
abstracting: (haveAandB<=haveA)
states: 6,089,331 (6)
abstracting: (haveAandB<=Clients)
states: 10,118,706 (7)
abstracting: (resA<=resB)
states: 6,957,471 (6)
abstracting: (resB<=6)
states: 2,210,304 (6)
abstracting: (98<=haveA2andB)
states: 0
abstracting: (resB<=57)
states: 10,119,981 (7)
abstracting: (haveB<=haveB)
states: 10,119,981 (7)
-> the formula is TRUE

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

MC time: 0m 7.906sec

checking: EF [[[[[[Clients<=55 | 92<=resB] | [~ [[51<=resA & [resA<=98 | haveAandB<=haveA2]]] & [63<=resB & ~ [[haveA<=18 & 28<=haveA2]]]]] | [[haveA2<=haveA2andB | [~ [[haveA2<=haveA | haveB<=47]] | 65<=haveB]] | [[[haveB<=resB & [[haveA<=resB & 78<=haveA2] | haveA2<=haveA]] | [~ [[resB<=38 & 92<=haveAandB]] | [[haveA2<=haveA2 & resB<=haveA2] | haveA<=haveA2andB]]] | ~ [[~ [resB<=haveAandB] & [~ [haveA<=27] | 99<=haveA2]]]]]] & [~ [[~ [[haveA2andB<=resA & [resA<=40 | haveA2<=haveA]]] | ~ [[~ [74<=haveA] & ~ [32<=haveA2]]]]] | ~ [haveA<=95]]] & ~ [haveA<=47]]]
normalized: E [true U [~ [haveA<=47] & [[~ [[~ [[haveA2andB<=resA & [resA<=40 | haveA2<=haveA]]] | ~ [[~ [32<=haveA2] & ~ [74<=haveA]]]]] | ~ [haveA<=95]] & [[[~ [[[99<=haveA2 | ~ [haveA<=27]] & ~ [resB<=haveAandB]]] | [[[haveA<=haveA2andB | [haveA2<=haveA2 & resB<=haveA2]] | ~ [[resB<=38 & 92<=haveAandB]]] | [haveB<=resB & [haveA2<=haveA | [haveA<=resB & 78<=haveA2]]]]] | [haveA2<=haveA2andB | [65<=haveB | ~ [[haveA2<=haveA | haveB<=47]]]]] | [[[63<=resB & ~ [[haveA<=18 & 28<=haveA2]]] & ~ [[51<=resA & [resA<=98 | haveAandB<=haveA2]]]] | [Clients<=55 | 92<=resB]]]]]]

abstracting: (92<=resB)
states: 0
abstracting: (Clients<=55)
states: 8,213,097 (6)
abstracting: (haveAandB<=haveA2)
states: 6,089,331 (6)
abstracting: (resA<=98)
states: 10,119,981 (7)
abstracting: (51<=resA)
states: 0
abstracting: (28<=haveA2)
states: 645,817 (5)
abstracting: (haveA<=18)
states: 8,046,557 (6)
abstracting: (63<=resB)
states: 0
abstracting: (haveB<=47)
states: 10,095,024 (7)
abstracting: (haveA2<=haveA)
states: 5,221,216 (6)
abstracting: (65<=haveB)
states: 0
abstracting: (haveA2<=haveA2andB)
states: 4,432,076 (6)
abstracting: (78<=haveA2)
states: 0
abstracting: (haveA<=resB)
states: 6,957,521 (6)
abstracting: (haveA2<=haveA)
states: 5,221,216 (6)
abstracting: (haveB<=resB)
states: 5,138,991 (6)
abstracting: (92<=haveAandB)
states: 0
abstracting: (resB<=38)
states: 9,646,872 (6)
abstracting: (resB<=haveA2)
states: 3,478,710 (6)
abstracting: (haveA2<=haveA2)
states: 10,119,981 (7)
abstracting: (haveA<=haveA2andB)
states: 4,432,076 (6)
abstracting: (resB<=haveAandB)
states: 3,065,115 (6)
abstracting: (haveA<=27)
states: 9,474,164 (6)
abstracting: (99<=haveA2)
states: 0
abstracting: (haveA<=95)
states: 10,119,981 (7)
abstracting: (74<=haveA)
states: 0
abstracting: (32<=haveA2)
states: 327,693 (5)
abstracting: (haveA2<=haveA)
states: 5,221,216 (6)
abstracting: (resA<=40)
states: 10,085,375 (7)
abstracting: (haveA2andB<=resA)
states: 6,089,331 (6)
abstracting: (haveA<=47)
states: 10,119,216 (7)
-> the formula is TRUE

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

MC time: 0m 5.092sec

checking: EF [[~ [[[[~ [[16<=haveAandB | haveA<=haveA2]] | [~ [haveA<=haveA] | ~ [haveB<=86]]] & ~ [[haveA2andB<=haveB & [[haveA2<=haveA & [34<=haveA2andB | haveA2<=resB]] | [~ [haveAandB<=Clients] | [36<=haveB | resB<=17]]]]]] | ~ [[8<=Clients | [[~ [[resB<=haveAandB & haveA<=74]] & haveB<=49] | [[[98<=haveA | haveB<=Clients] & haveA2andB<=haveAandB] & [haveAandB<=9 | [haveA2andB<=haveAandB | 64<=haveA2andB]]]]]]]] & [~ [[[[[haveA2<=haveAandB & ~ [[haveAandB<=haveA2 & haveB<=haveB]]] | [[[41<=haveA2 & Clients<=haveA2andB] & ~ [35<=haveAandB]] | [[resA<=haveA2 & 70<=resB] | haveB<=haveB]]] & ~ [resB<=haveA2andB]] & ~ [[59<=haveB & ~ [[resA<=haveB & 24<=haveB]]]]]] & ~ [[1<=haveA2 & [[[[[resB<=resA & haveA2andB<=33] | haveA2andB<=resA] & ~ [[92<=haveA2 & resA<=haveAandB]]] & ~ [[[haveA2<=49 | haveA<=resB] & ~ [resB<=67]]]] & [[1<=Clients | ~ [56<=resB]] & Clients<=96]]]]]]]
normalized: E [true U [[~ [[1<=haveA2 & [[Clients<=96 & [1<=Clients | ~ [56<=resB]]] & [~ [[~ [resB<=67] & [haveA2<=49 | haveA<=resB]]] & [~ [[92<=haveA2 & resA<=haveAandB]] & [haveA2andB<=resA | [resB<=resA & haveA2andB<=33]]]]]]] & ~ [[~ [[59<=haveB & ~ [[resA<=haveB & 24<=haveB]]]] & [~ [resB<=haveA2andB] & [[[haveB<=haveB | [resA<=haveA2 & 70<=resB]] | [~ [35<=haveAandB] & [41<=haveA2 & Clients<=haveA2andB]]] | [haveA2<=haveAandB & ~ [[haveAandB<=haveA2 & haveB<=haveB]]]]]]]] & ~ [[~ [[8<=Clients | [[[haveAandB<=9 | [haveA2andB<=haveAandB | 64<=haveA2andB]] & [haveA2andB<=haveAandB & [98<=haveA | haveB<=Clients]]] | [haveB<=49 & ~ [[resB<=haveAandB & haveA<=74]]]]]] | [~ [[haveA2andB<=haveB & [[[36<=haveB | resB<=17] | ~ [haveAandB<=Clients]] | [haveA2<=haveA & [34<=haveA2andB | haveA2<=resB]]]]] & [[~ [haveB<=86] | ~ [haveA<=haveA]] | ~ [[16<=haveAandB | haveA<=haveA2]]]]]]]]

abstracting: (haveA<=haveA2)
states: 5,221,216 (6)
abstracting: (16<=haveAandB)
states: 1,653,456 (6)
abstracting: (haveA<=haveA)
states: 10,119,981 (7)
abstracting: (haveB<=86)
states: 10,119,981 (7)
abstracting: (haveA2<=resB)
states: 6,957,521 (6)
abstracting: (34<=haveA2andB)
states: 56,202 (4)
abstracting: (haveA2<=haveA)
states: 5,221,216 (6)
abstracting: (haveAandB<=Clients)
states: 10,118,706 (7)
abstracting: (resB<=17)
states: 5,529,675 (6)
abstracting: (36<=haveB)
states: 795,549 (5)
abstracting: (haveA2andB<=haveB)
states: 7,333,041 (6)
abstracting: (haveA<=74)
states: 10,119,981 (7)
abstracting: (resB<=haveAandB)
states: 3,065,115 (6)
abstracting: (haveB<=49)
states: 10,114,830 (7)
abstracting: (haveB<=Clients)
states: 8,671,221 (6)
abstracting: (98<=haveA)
states: 0
abstracting: (haveA2andB<=haveAandB)
states: 5,300,166 (6)
abstracting: (64<=haveA2andB)
states: 0
abstracting: (haveA2andB<=haveAandB)
states: 5,300,166 (6)
abstracting: (haveAandB<=9)
states: 6,590,455 (6)
abstracting: (8<=Clients)
states: 10,097,163 (7)
abstracting: (haveB<=haveB)
states: 10,119,981 (7)
abstracting: (haveAandB<=haveA2)
states: 6,089,331 (6)
abstracting: (haveA2<=haveAandB)
states: 4,432,076 (6)
abstracting: (Clients<=haveA2andB)
states: 5,151 (3)
abstracting: (41<=haveA2)
states: 34,596 (4)
abstracting: (35<=haveAandB)
states: 42,636 (4)
abstracting: (70<=resB)
states: 0
abstracting: (resA<=haveA2)
states: 5,221,191 (6)
abstracting: (haveB<=haveB)
states: 10,119,981 (7)
abstracting: (resB<=haveA2andB)
states: 3,065,115 (6)
abstracting: (24<=haveB)
states: 3,015,717 (6)
abstracting: (resA<=haveB)
states: 6,957,471 (6)
abstracting: (59<=haveB)
states: 0
abstracting: (haveA2andB<=33)
states: 10,063,779 (7)
abstracting: (resB<=resA)
states: 3,478,710 (6)
abstracting: (haveA2andB<=resA)
states: 6,089,331 (6)
abstracting: (resA<=haveAandB)
states: 4,432,026 (6)
abstracting: (92<=haveA2)
states: 0
abstracting: (haveA<=resB)
states: 6,957,521 (6)
abstracting: (haveA2<=49)
states: 10,119,930 (7)
abstracting: (resB<=67)
states: 10,119,981 (7)
abstracting: (56<=resB)
states: 0
abstracting: (1<=Clients)
states: 10,119,780 (7)
abstracting: (Clients<=96)
states: 10,119,925 (7)
abstracting: (1<=haveA2)
states: 9,487,480 (6)
-> the formula is TRUE

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

MC time: 0m10.166sec

totally nodes used: 4542625 (4.5e+06)
number of garbage collections: 0
fire ops cache: hits/miss/sum: 76657405 11053368 87710773
used/not used/entry size/cache size: 12872414 54236450 16 1024MB
basic ops cache: hits/miss/sum: 53454006 31488216 84942222
used/not used/entry size/cache size: 14455458 2321758 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: 7894780 2039023 9933803
used/not used/entry size/cache size: 1694669 6693939 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 62965891
1 3931152
2 156678
3 26488
4 11986
5 6613
6 3296
7 1571
8 864
9 498
>= 10 3827

Total processing time: 0m59.504sec


BK_STOP 1679339727600

--------------------
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:1256 (209), effective:400 (66)

initing FirstDep: 0m 0.000sec


iterations count:160 (26), effective:55 (9)

iterations count:568 (94), effective:153 (25)

iterations count:149 (24), effective:81 (13)

iterations count:863 (143), effective:334 (55)

iterations count:216 (36), effective:83 (13)

iterations count:742 (123), effective:278 (46)

iterations count:758 (126), effective:215 (35)

iterations count:146 (24), effective:84 (14)

iterations count:1034 (172), effective:356 (59)

iterations count:374 (62), effective:145 (24)

iterations count:636 (106), effective:194 (32)

iterations count:360 (60), effective:181 (30)

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

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