maggicl/soft-an04
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

WIP on grid search

Browse source
This commit is contained in:
Claudio Maggioni 2023-05-09 11:07:55 +02:00
parent 942de9a1ae
commit de2476e2d6
135 changed files with 6055 additions and 32 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

41
ReversalModel/reversal.pml.m4
View file

@ -1,9 +1,9 @@
define(N, `2') /*
define(LENGTH, `3') m4 for loop definition
define(R, `2')
define(`for',`ifelse($#,0,``$0'',`ifelse(eval($2<=$3),1, define(`for',`ifelse($#,0,``$0'',`ifelse(eval($2<=$3),1,
`pushdef(`$1',$2)$4`'popdef(`$1')$0(`$1',incr($2),$3,`$4')')')') `pushdef(`$1',$2)$4`'popdef(`$1')$0(`$1',incr($2),$3,`$4')')')')
*/
int to_reverse[LENGTH]; // array to reverse int to_reverse[LENGTH]; // array to reverse
int reversed_seq[LENGTH]; // for SequentialReverser: where the reverse is stored int reversed_seq[LENGTH]; // for SequentialReverser: where the reverse is stored
@ -21,7 +21,7 @@ proctype ThreadedReverser(int from; int to; int n) {
printf("proc[%d]: started from=%d to=%d\n", n, from, to); printf("proc[%d]: started from=%d to=%d\n", n, from, to);
int k; int k;
for (k: from .. to) { for (k: from .. (to - 1)) {
printf("reversed_par[%d] = to_reverse[%d]\n", LENGTH - k - 1, k); printf("reversed_par[%d] = to_reverse[%d]\n", LENGTH - k - 1, k);
reversed_par[LENGTH - k - 1] = to_reverse[k]; reversed_par[LENGTH - k - 1] = to_reverse[k];
} }
@ -48,7 +48,7 @@ init {
{ {
int k; int k;
for (k: 0 .. (LENGTH - 1)) { for (k: 0 .. (LENGTH - 1)) {
reversed_par[LENGTH - k - 1] = to_reverse[k]; reversed_seq[LENGTH - k - 1] = to_reverse[k];
printf("reversed_seq[%d] = to_reverse[%d]\n", LENGTH - k - 1, k); printf("reversed_seq[%d] = to_reverse[%d]\n", LENGTH - k - 1, k);
} }
done[0] = true; // mark sequential end done[0] = true; // mark sequential end
@ -62,14 +62,14 @@ init {
int s = LENGTH / N; int s = LENGTH / N;
// fork section // fork section
for (n: 1 .. N) { for (n: 0 .. (N - 1)) {
int from = n * s; int from = n * s;
int to; int to;
if if
:: (n == N) -> to = LENGTH - 1; :: (n == N - 1) -> to = LENGTH;
:: else -> to = n * s + s - 1; :: else -> to = n * s + s;
fi fi
run ThreadedReverser(from, to, n); // run as "thread n" run ThreadedReverser(from, to, n + 1); // run as "thread n"
} }
// join section // join section
@ -96,15 +96,30 @@ init {
ltl seq_eq_parallel { ltl seq_eq_parallel {
// the variable seq_eq_to_parallel will never be false if all the elements // the variable seq_eq_to_parallel will never be false if all the elements
// between the sequential and parallel reversed arrays are equal // between the sequential and parallel reversed arrays are equal
(done[0] == false || done[N] == false) U (seq_eq_to_parallel == true) [] (seq_eq_to_parallel == true)
} }
ltl termination { ltl termination {
// <> (done[0] == true for(`x', 1, N, ` && done[x] == true')) // termination happens when the sequential reverser terminates
// (done[0] is true) and the last process in the parallel reverser joins
// (done[N] is true)
<> (done[0] == true && done[N] == true) <> (done[0] == true && done[N] == true)
} }
// Due to avoid excessive parser complexity when checking the model
// with other ltl properties the correctness_seq is excluded by m4 from the
// ProMeLa source when there is no need to check it
// ifelse(LTL, correctness_seq, `
ltl correctness_seq { ltl correctness_seq {
done[0] == true -> (true for(`k', 0, LENGTH-1, ` && [] (done[0] == true -> (true for(`k', 0, LENGTH-1, ` &&
reversed_seq[eval(LENGTH - k - 1)] == to_reverse[k]')) reversed_seq[eval(LENGTH - k - 1)] == to_reverse[k]')))
} }
// ', `')
// Similar exclusion logic is applied to correctness_par
// ifelse(LTL, correctness_par, `
ltl correctness_par {
[] (done[2] == true -> (true for(`k', 0, LENGTH / N - 1, ` &&
reversed_par[eval(LENGTH - k - 1)] == to_reverse[k]')))
}
// ', `')

144
ReversalModel/time.csv Normal file
View file

@ -0,0 +1,144 @@
seq_eq_parallel,2,3,2,0.14,0.03,0.02
seq_eq_parallel,2,3,3,0.12,0.03,0.02
seq_eq_parallel,2,3,4,0.13,0.04,0.02
seq_eq_parallel,2,3,5,0.13,0.05,0.02
seq_eq_parallel,2,3,6,0.14,0.06,0.02
seq_eq_parallel,2,3,7,0.16,0.07,0.03
seq_eq_parallel,2,3,8,0.17,0.09,0.03
seq_eq_parallel,2,3,9,0.20,0.11,0.03
seq_eq_parallel,2,3,10,0.23,0.14,0.03
seq_eq_parallel,2,3,2,0.12,0.03,0.03
seq_eq_parallel,2,3,3,0.12,0.03,0.02
seq_eq_parallel,2,3,4,0.13,0.04,0.02
seq_eq_parallel,2,3,5,0.13,0.05,0.02
seq_eq_parallel,2,3,2,0.12,0.03,0.02
seq_eq_parallel,2,3,3,0.12,0.03,0.03
seq_eq_parallel,2,3,4,0.12,0.04,0.02
seq_eq_parallel,2,3,5,0.14,0.05,0.03
seq_eq_parallel,2,3,6,0.14,0.06,0.02
seq_eq_parallel,2,3,7,0.16,0.07,0.02
seq_eq_parallel,2,3,8,0.18,0.09,0.03
seq_eq_parallel,2,4,2,0.12,0.04,0.02
seq_eq_parallel,2,4,3,0.14,0.06,0.02
seq_eq_parallel,2,4,4,0.18,0.10,0.03
seq_eq_parallel,2,4,5,0.26,0.17,0.03
seq_eq_parallel,2,4,6,0.37,0.28,0.03
seq_eq_parallel,2,4,7,0.58,0.48,0.04
seq_eq_parallel,2,4,8,0.82,0.71,0.05
seq_eq_parallel,2,5,2,0.15,0.06,0.03
seq_eq_parallel,2,5,3,0.26,0.17,0.03
seq_eq_parallel,2,5,4,0.56,0.45,0.04
seq_eq_parallel,2,5,5,1.21,1.08,0.07
seq_eq_parallel,2,5,6,2.68,2.45,0.16
seq_eq_parallel,2,5,7,5.27,4.93,0.27
seq_eq_parallel,2,5,8,9.00,8.38,0.44
seq_eq_parallel,2,6,2,0.34,0.16,0.03
seq_eq_parallel,2,6,3,0.92,0.72,0.05
seq_eq_parallel,2,6,4,3.01,2.70,0.16
seq_eq_parallel,2,6,5,8.75,8.18,0.42
seq_eq_parallel,2,6,6,24.91,23.53,1.20
seq_eq_parallel,2,6,7,63.94,60.85,2.89
seq_eq_parallel,2,6,8,342.41,160.09,126.62
seq_eq_parallel,2,7,2,0.83,0.51,0.05
seq_eq_parallel,2,7,3,5.13,4.67,0.31
seq_eq_parallel,2,7,4,24.95,23.38,1.38
seq_eq_parallel,2,7,5,101.42,95.14,5.84
seq_eq_parallel,2,8,2,2.14,1.75,0.11
seq_eq_parallel,2,8,3,19.55,18.40,0.98
seq_eq_parallel,3,3,2,0.30,0.05,0.06
seq_eq_parallel,3,3,3,0.33,0.06,0.07
seq_eq_parallel,3,3,4,0.44,0.08,0.07
seq_eq_parallel,3,3,5,0.52,0.11,0.09
seq_eq_parallel,3,3,6,0.75,0.15,0.08
seq_eq_parallel,3,3,7,0.77,0.21,0.08
seq_eq_parallel,3,3,8,1.00,0.28,0.10
seq_eq_parallel,3,4,2,0.41,0.08,0.07
seq_eq_parallel,3,4,3,0.70,0.16,0.08
seq_eq_parallel,3,4,4,1.06,0.31,0.10
seq_eq_parallel,3,4,5,1.71,0.61,0.13
seq_eq_parallel,3,4,6,3.81,1.14,0.31
seq_eq_parallel,3,4,7,5.40,1.95,0.47
seq_eq_parallel,3,4,8,6.31,2.87,0.49
seq_eq_parallel,3,5,2,0.90,0.19,0.08
seq_eq_parallel,3,5,3,1.82,0.67,0.18
seq_eq_parallel,3,5,4,4.27,1.83,0.33
seq_eq_parallel,3,5,5,13.23,4.74,1.46
seq_eq_parallel,3,5,6,75.60,14.34,16.88
seq_eq_parallel,3,5,7,226.55,34.58,62.64
seq_eq_parallel,4,3,2,0.43,0.05,0.06
seq_eq_parallel,4,3,3,0.39,0.08,0.07
seq_eq_parallel,4,3,4,0.41,0.10,0.05
seq_eq_parallel,4,3,5,0.38,0.15,0.06
seq_eq_parallel,4,3,6,0.48,0.21,0.08
seq_eq_parallel,4,3,7,0.63,0.33,0.10
seq_eq_parallel,4,3,8,0.67,0.37,0.10
seq_eq_parallel,4,4,2,0.44,0.12,0.07
seq_eq_parallel,4,4,3,0.58,0.30,0.06
seq_eq_parallel,4,4,4,1.19,0.77,0.14
seq_eq_parallel,4,4,5,2.61,1.53,0.31
seq_eq_parallel,4,4,6,4.05,2.87,0.55
seq_eq_parallel,4,4,7,6.40,4.73,1.03
seq_eq_parallel,4,4,8,10.47,7.63,1.96
seq_eq_parallel,4,5,2,0.99,0.46,0.11
seq_eq_parallel,4,5,3,2.40,1.72,0.28
seq_eq_parallel,4,5,4,6.93,5.02,1.14
seq_eq_parallel,4,5,5,22.23,13.75,5.59
seq_eq_parallel,4,5,6,139.63,39.78,43.62
seq_eq_parallel,5,3,2,0.44,0.07,0.07
seq_eq_parallel,5,3,3,0.38,0.13,0.07
seq_eq_parallel,5,3,4,0.51,0.19,0.09
seq_eq_parallel,5,3,5,0.58,0.31,0.08
seq_eq_parallel,5,3,6,0.65,0.42,0.07
seq_eq_parallel,5,3,7,0.82,0.58,0.08
seq_eq_parallel,5,3,8,1.28,0.87,0.14
seq_eq_parallel,5,4,2,0.53,0.15,0.08
seq_eq_parallel,5,4,3,0.80,0.40,0.09
seq_eq_parallel,5,4,4,1.29,0.90,0.14
seq_eq_parallel,5,4,5,2.67,1.93,0.28
seq_eq_parallel,5,4,6,4.68,3.51,0.60
seq_eq_parallel,5,4,7,11.94,6.67,2.18
seq_eq_parallel,5,4,8,18.38,10.46,2.77
seq_eq_parallel,5,5,2,3.16,1.22,0.20
seq_eq_parallel,5,5,3,10.96,5.20,1.10
seq_eq_parallel,5,5,4,68.06,18.49,13.30
seq_eq_parallel,6,3,2,0.46,0.11,0.08
seq_eq_parallel,6,3,3,0.60,0.22,0.09
seq_eq_parallel,6,3,4,0.79,0.38,0.09
seq_eq_parallel,6,3,5,1.48,0.66,0.13
seq_eq_parallel,6,3,6,2.33,1.06,0.21
seq_eq_parallel,6,3,7,3.64,1.49,0.23
seq_eq_parallel,6,3,8,4.19,2.08,0.31
seq_eq_parallel,6,4,2,0.74,0.34,0.08
seq_eq_parallel,6,4,3,1.84,0.92,0.13
seq_eq_parallel,6,4,4,4.65,2.20,0.33
seq_eq_parallel,6,4,5,10.27,4.76,0.92
seq_eq_parallel,6,4,6,24.70,9.22,3.10
seq_eq_parallel,6,4,7,52.76,16.49,7.90
seq_eq_parallel,6,4,8,196.66,36.23,46.28
seq_eq_parallel,6,5,2,2.60,1.04,0.16
seq_eq_parallel,6,5,3,15.11,4.98,1.93
seq_eq_parallel,6,5,4,76.82,18.34,15.81
seq_eq_parallel,7,3,2,0.52,0.21,0.07
seq_eq_parallel,7,3,3,1.12,0.46,0.11
seq_eq_parallel,7,3,4,1.97,0.87,0.14
seq_eq_parallel,7,3,5,3.74,1.45,0.23
seq_eq_parallel,7,3,6,4.36,2.24,0.31
seq_eq_parallel,7,3,7,6.82,3.38,0.53
seq_eq_parallel,7,3,8,10.21,4.93,0.93
seq_eq_parallel,7,4,2,2.00,0.75,0.14
seq_eq_parallel,7,4,3,4.59,2.15,0.34
seq_eq_parallel,7,4,4,13.71,5.35,1.20
seq_eq_parallel,7,4,5,37.15,11.78,4.54
seq_eq_parallel,7,4,6,107.50,25.80,21.47
seq_eq_parallel,7,4,7,319.25,55.45,79.14
seq_eq_parallel,8,3,2,0.94,0.42,0.10
seq_eq_parallel,8,3,3,2.75,1.01,0.18
seq_eq_parallel,8,3,4,3.50,1.84,0.24
seq_eq_parallel,8,3,5,6.42,3.23,0.46
seq_eq_parallel,8,3,6,10.36,5.18,0.87
seq_eq_parallel,8,3,7,19.11,8.07,1.93
seq_eq_parallel,8,3,8,39.00,12.05,4.40
seq_eq_parallel,8,4,2,2.94,1.46,0.16
seq_eq_parallel,8,4,3,11.56,5.04,0.81
seq_eq_parallel,8,4,4,42.06,13.24,6.15
seq_eq_parallel,8,4,5,162.17,34.75,32.92
1 seq_eq_parallel 2 3 2 0.14 0.03 0.02
2 seq_eq_parallel 2 3 3 0.12 0.03 0.02
3 seq_eq_parallel 2 3 4 0.13 0.04 0.02
4 seq_eq_parallel 2 3 5 0.13 0.05 0.02
5 seq_eq_parallel 2 3 6 0.14 0.06 0.02
6 seq_eq_parallel 2 3 7 0.16 0.07 0.03
7 seq_eq_parallel 2 3 8 0.17 0.09 0.03
8 seq_eq_parallel 2 3 9 0.20 0.11 0.03
9 seq_eq_parallel 2 3 10 0.23 0.14 0.03
10 seq_eq_parallel 2 3 2 0.12 0.03 0.03
11 seq_eq_parallel 2 3 3 0.12 0.03 0.02
12 seq_eq_parallel 2 3 4 0.13 0.04 0.02
13 seq_eq_parallel 2 3 5 0.13 0.05 0.02
14 seq_eq_parallel 2 3 2 0.12 0.03 0.02
15 seq_eq_parallel 2 3 3 0.12 0.03 0.03
16 seq_eq_parallel 2 3 4 0.12 0.04 0.02
17 seq_eq_parallel 2 3 5 0.14 0.05 0.03
18 seq_eq_parallel 2 3 6 0.14 0.06 0.02
19 seq_eq_parallel 2 3 7 0.16 0.07 0.02
20 seq_eq_parallel 2 3 8 0.18 0.09 0.03
21 seq_eq_parallel 2 4 2 0.12 0.04 0.02
22 seq_eq_parallel 2 4 3 0.14 0.06 0.02
23 seq_eq_parallel 2 4 4 0.18 0.10 0.03
24 seq_eq_parallel 2 4 5 0.26 0.17 0.03
25 seq_eq_parallel 2 4 6 0.37 0.28 0.03
26 seq_eq_parallel 2 4 7 0.58 0.48 0.04
27 seq_eq_parallel 2 4 8 0.82 0.71 0.05
28 seq_eq_parallel 2 5 2 0.15 0.06 0.03
29 seq_eq_parallel 2 5 3 0.26 0.17 0.03
30 seq_eq_parallel 2 5 4 0.56 0.45 0.04
31 seq_eq_parallel 2 5 5 1.21 1.08 0.07
32 seq_eq_parallel 2 5 6 2.68 2.45 0.16
33 seq_eq_parallel 2 5 7 5.27 4.93 0.27
34 seq_eq_parallel 2 5 8 9.00 8.38 0.44
35 seq_eq_parallel 2 6 2 0.34 0.16 0.03
36 seq_eq_parallel 2 6 3 0.92 0.72 0.05
37 seq_eq_parallel 2 6 4 3.01 2.70 0.16
38 seq_eq_parallel 2 6 5 8.75 8.18 0.42
39 seq_eq_parallel 2 6 6 24.91 23.53 1.20
40 seq_eq_parallel 2 6 7 63.94 60.85 2.89
41 seq_eq_parallel 2 6 8 342.41 160.09 126.62
42 seq_eq_parallel 2 7 2 0.83 0.51 0.05
43 seq_eq_parallel 2 7 3 5.13 4.67 0.31
44 seq_eq_parallel 2 7 4 24.95 23.38 1.38
45 seq_eq_parallel 2 7 5 101.42 95.14 5.84
46 seq_eq_parallel 2 8 2 2.14 1.75 0.11
47 seq_eq_parallel 2 8 3 19.55 18.40 0.98
48 seq_eq_parallel 3 3 2 0.30 0.05 0.06
49 seq_eq_parallel 3 3 3 0.33 0.06 0.07
50 seq_eq_parallel 3 3 4 0.44 0.08 0.07
51 seq_eq_parallel 3 3 5 0.52 0.11 0.09
52 seq_eq_parallel 3 3 6 0.75 0.15 0.08
53 seq_eq_parallel 3 3 7 0.77 0.21 0.08
54 seq_eq_parallel 3 3 8 1.00 0.28 0.10
55 seq_eq_parallel 3 4 2 0.41 0.08 0.07
56 seq_eq_parallel 3 4 3 0.70 0.16 0.08
57 seq_eq_parallel 3 4 4 1.06 0.31 0.10
58 seq_eq_parallel 3 4 5 1.71 0.61 0.13
59 seq_eq_parallel 3 4 6 3.81 1.14 0.31
60 seq_eq_parallel 3 4 7 5.40 1.95 0.47
61 seq_eq_parallel 3 4 8 6.31 2.87 0.49
62 seq_eq_parallel 3 5 2 0.90 0.19 0.08
63 seq_eq_parallel 3 5 3 1.82 0.67 0.18
64 seq_eq_parallel 3 5 4 4.27 1.83 0.33
65 seq_eq_parallel 3 5 5 13.23 4.74 1.46
66 seq_eq_parallel 3 5 6 75.60 14.34 16.88
67 seq_eq_parallel 3 5 7 226.55 34.58 62.64
68 seq_eq_parallel 4 3 2 0.43 0.05 0.06
69 seq_eq_parallel 4 3 3 0.39 0.08 0.07
70 seq_eq_parallel 4 3 4 0.41 0.10 0.05
71 seq_eq_parallel 4 3 5 0.38 0.15 0.06
72 seq_eq_parallel 4 3 6 0.48 0.21 0.08
73 seq_eq_parallel 4 3 7 0.63 0.33 0.10
74 seq_eq_parallel 4 3 8 0.67 0.37 0.10
75 seq_eq_parallel 4 4 2 0.44 0.12 0.07
76 seq_eq_parallel 4 4 3 0.58 0.30 0.06
77 seq_eq_parallel 4 4 4 1.19 0.77 0.14
78 seq_eq_parallel 4 4 5 2.61 1.53 0.31
79 seq_eq_parallel 4 4 6 4.05 2.87 0.55
80 seq_eq_parallel 4 4 7 6.40 4.73 1.03
81 seq_eq_parallel 4 4 8 10.47 7.63 1.96
82 seq_eq_parallel 4 5 2 0.99 0.46 0.11
83 seq_eq_parallel 4 5 3 2.40 1.72 0.28
84 seq_eq_parallel 4 5 4 6.93 5.02 1.14
85 seq_eq_parallel 4 5 5 22.23 13.75 5.59
86 seq_eq_parallel 4 5 6 139.63 39.78 43.62
87 seq_eq_parallel 5 3 2 0.44 0.07 0.07
88 seq_eq_parallel 5 3 3 0.38 0.13 0.07
89 seq_eq_parallel 5 3 4 0.51 0.19 0.09
90 seq_eq_parallel 5 3 5 0.58 0.31 0.08
91 seq_eq_parallel 5 3 6 0.65 0.42 0.07
92 seq_eq_parallel 5 3 7 0.82 0.58 0.08
93 seq_eq_parallel 5 3 8 1.28 0.87 0.14
94 seq_eq_parallel 5 4 2 0.53 0.15 0.08
95 seq_eq_parallel 5 4 3 0.80 0.40 0.09
96 seq_eq_parallel 5 4 4 1.29 0.90 0.14
97 seq_eq_parallel 5 4 5 2.67 1.93 0.28
98 seq_eq_parallel 5 4 6 4.68 3.51 0.60
99 seq_eq_parallel 5 4 7 11.94 6.67 2.18
100 seq_eq_parallel 5 4 8 18.38 10.46 2.77
101 seq_eq_parallel 5 5 2 3.16 1.22 0.20
102 seq_eq_parallel 5 5 3 10.96 5.20 1.10
103 seq_eq_parallel 5 5 4 68.06 18.49 13.30
104 seq_eq_parallel 6 3 2 0.46 0.11 0.08
105 seq_eq_parallel 6 3 3 0.60 0.22 0.09
106 seq_eq_parallel 6 3 4 0.79 0.38 0.09
107 seq_eq_parallel 6 3 5 1.48 0.66 0.13
108 seq_eq_parallel 6 3 6 2.33 1.06 0.21
109 seq_eq_parallel 6 3 7 3.64 1.49 0.23
110 seq_eq_parallel 6 3 8 4.19 2.08 0.31
111 seq_eq_parallel 6 4 2 0.74 0.34 0.08
112 seq_eq_parallel 6 4 3 1.84 0.92 0.13
113 seq_eq_parallel 6 4 4 4.65 2.20 0.33
114 seq_eq_parallel 6 4 5 10.27 4.76 0.92
115 seq_eq_parallel 6 4 6 24.70 9.22 3.10
116 seq_eq_parallel 6 4 7 52.76 16.49 7.90
117 seq_eq_parallel 6 4 8 196.66 36.23 46.28
118 seq_eq_parallel 6 5 2 2.60 1.04 0.16
119 seq_eq_parallel 6 5 3 15.11 4.98 1.93
120 seq_eq_parallel 6 5 4 76.82 18.34 15.81
121 seq_eq_parallel 7 3 2 0.52 0.21 0.07
122 seq_eq_parallel 7 3 3 1.12 0.46 0.11
123 seq_eq_parallel 7 3 4 1.97 0.87 0.14
124 seq_eq_parallel 7 3 5 3.74 1.45 0.23
125 seq_eq_parallel 7 3 6 4.36 2.24 0.31
126 seq_eq_parallel 7 3 7 6.82 3.38 0.53
127 seq_eq_parallel 7 3 8 10.21 4.93 0.93
128 seq_eq_parallel 7 4 2 2.00 0.75 0.14
129 seq_eq_parallel 7 4 3 4.59 2.15 0.34
130 seq_eq_parallel 7 4 4 13.71 5.35 1.20
131 seq_eq_parallel 7 4 5 37.15 11.78 4.54
132 seq_eq_parallel 7 4 6 107.50 25.80 21.47
133 seq_eq_parallel 7 4 7 319.25 55.45 79.14
134 seq_eq_parallel 8 3 2 0.94 0.42 0.10
135 seq_eq_parallel 8 3 3 2.75 1.01 0.18
136 seq_eq_parallel 8 3 4 3.50 1.84 0.24
137 seq_eq_parallel 8 3 5 6.42 3.23 0.46
138 seq_eq_parallel 8 3 6 10.36 5.18 0.87
139 seq_eq_parallel 8 3 7 19.11 8.07 1.93
140 seq_eq_parallel 8 3 8 39.00 12.05 4.40
141 seq_eq_parallel 8 4 2 2.94 1.46 0.16
142 seq_eq_parallel 8 4 3 11.56 5.04 0.81
143 seq_eq_parallel 8 4 4 42.06 13.24 6.15
144 seq_eq_parallel 8 4 5 162.17 34.75 32.92

288
ReversalModel/time.txt Normal file
View file

@ -0,0 +1,288 @@
seq_eq_parallel,2,3,2,
0.14 real 0.03 user 0.02 sys
seq_eq_parallel,2,3,3,
0.12 real 0.03 user 0.02 sys
seq_eq_parallel,2,3,4,
0.13 real 0.04 user 0.02 sys
seq_eq_parallel,2,3,5,
0.13 real 0.05 user 0.02 sys
seq_eq_parallel,2,3,6,
0.14 real 0.06 user 0.02 sys
seq_eq_parallel,2,3,7,
0.16 real 0.07 user 0.03 sys
seq_eq_parallel,2,3,8,
0.17 real 0.09 user 0.03 sys
seq_eq_parallel,2,3,9,
0.20 real 0.11 user 0.03 sys
seq_eq_parallel,2,3,10,
0.23 real 0.14 user 0.03 sys
seq_eq_parallel,2,3,2,
0.12 real 0.03 user 0.03 sys
seq_eq_parallel,2,3,3,
0.12 real 0.03 user 0.02 sys
seq_eq_parallel,2,3,4,
0.13 real 0.04 user 0.02 sys
seq_eq_parallel,2,3,5,
0.13 real 0.05 user 0.02 sys
seq_eq_parallel,2,3,2,
0.12 real 0.03 user 0.02 sys
seq_eq_parallel,2,3,3,
0.12 real 0.03 user 0.03 sys
seq_eq_parallel,2,3,4,
0.12 real 0.04 user 0.02 sys
seq_eq_parallel,2,3,5,
0.14 real 0.05 user 0.03 sys
seq_eq_parallel,2,3,6,
0.14 real 0.06 user 0.02 sys
seq_eq_parallel,2,3,7,
0.16 real 0.07 user 0.02 sys
seq_eq_parallel,2,3,8,
0.18 real 0.09 user 0.03 sys
seq_eq_parallel,2,4,2,
0.12 real 0.04 user 0.02 sys
seq_eq_parallel,2,4,3,
0.14 real 0.06 user 0.02 sys
seq_eq_parallel,2,4,4,
0.18 real 0.10 user 0.03 sys
seq_eq_parallel,2,4,5,
0.26 real 0.17 user 0.03 sys
seq_eq_parallel,2,4,6,
0.37 real 0.28 user 0.03 sys
seq_eq_parallel,2,4,7,
0.58 real 0.48 user 0.04 sys
seq_eq_parallel,2,4,8,
0.82 real 0.71 user 0.05 sys
seq_eq_parallel,2,5,2,
0.15 real 0.06 user 0.03 sys
seq_eq_parallel,2,5,3,
0.26 real 0.17 user 0.03 sys
seq_eq_parallel,2,5,4,
0.56 real 0.45 user 0.04 sys
seq_eq_parallel,2,5,5,
1.21 real 1.08 user 0.07 sys
seq_eq_parallel,2,5,6,
2.68 real 2.45 user 0.16 sys
seq_eq_parallel,2,5,7,
5.27 real 4.93 user 0.27 sys
seq_eq_parallel,2,5,8,
9.00 real 8.38 user 0.44 sys
seq_eq_parallel,2,6,2,
0.34 real 0.16 user 0.03 sys
seq_eq_parallel,2,6,3,
0.92 real 0.72 user 0.05 sys
seq_eq_parallel,2,6,4,
3.01 real 2.70 user 0.16 sys
seq_eq_parallel,2,6,5,
8.75 real 8.18 user 0.42 sys
seq_eq_parallel,2,6,6,
24.91 real 23.53 user 1.20 sys
seq_eq_parallel,2,6,7,
63.94 real 60.85 user 2.89 sys
seq_eq_parallel,2,6,8,
342.41 real 160.09 user 126.62 sys
seq_eq_parallel,2,7,2,
0.83 real 0.51 user 0.05 sys
seq_eq_parallel,2,7,3,
5.13 real 4.67 user 0.31 sys
seq_eq_parallel,2,7,4,
24.95 real 23.38 user 1.38 sys
seq_eq_parallel,2,7,5,
101.42 real 95.14 user 5.84 sys
seq_eq_parallel,2,8,2,
2.14 real 1.75 user 0.11 sys
seq_eq_parallel,2,8,3,
19.55 real 18.40 user 0.98 sys
seq_eq_parallel,3,3,2,
0.30 real 0.05 user 0.06 sys
seq_eq_parallel,3,3,3,
0.33 real 0.06 user 0.07 sys
seq_eq_parallel,3,3,4,
0.44 real 0.08 user 0.07 sys
seq_eq_parallel,3,3,5,
0.52 real 0.11 user 0.09 sys
seq_eq_parallel,3,3,6,
0.75 real 0.15 user 0.08 sys
seq_eq_parallel,3,3,7,
0.77 real 0.21 user 0.08 sys
seq_eq_parallel,3,3,8,
1.00 real 0.28 user 0.10 sys
seq_eq_parallel,3,4,2,
0.41 real 0.08 user 0.07 sys
seq_eq_parallel,3,4,3,
0.70 real 0.16 user 0.08 sys
seq_eq_parallel,3,4,4,
1.06 real 0.31 user 0.10 sys
seq_eq_parallel,3,4,5,
1.71 real 0.61 user 0.13 sys
seq_eq_parallel,3,4,6,
3.81 real 1.14 user 0.31 sys
seq_eq_parallel,3,4,7,
5.40 real 1.95 user 0.47 sys
seq_eq_parallel,3,4,8,
6.31 real 2.87 user 0.49 sys
seq_eq_parallel,3,5,2,
0.90 real 0.19 user 0.08 sys
seq_eq_parallel,3,5,3,
1.82 real 0.67 user 0.18 sys
seq_eq_parallel,3,5,4,
4.27 real 1.83 user 0.33 sys
seq_eq_parallel,3,5,5,
13.23 real 4.74 user 1.46 sys
seq_eq_parallel,3,5,6,
75.60 real 14.34 user 16.88 sys
seq_eq_parallel,3,5,7,
226.55 real 34.58 user 62.64 sys
seq_eq_parallel,4,3,2,
0.43 real 0.05 user 0.06 sys
seq_eq_parallel,4,3,3,
0.39 real 0.08 user 0.07 sys
seq_eq_parallel,4,3,4,
0.41 real 0.10 user 0.05 sys
seq_eq_parallel,4,3,5,
0.38 real 0.15 user 0.06 sys
seq_eq_parallel,4,3,6,
0.48 real 0.21 user 0.08 sys
seq_eq_parallel,4,3,7,
0.63 real 0.33 user 0.10 sys
seq_eq_parallel,4,3,8,
0.67 real 0.37 user 0.10 sys
seq_eq_parallel,4,4,2,
0.44 real 0.12 user 0.07 sys
seq_eq_parallel,4,4,3,
0.58 real 0.30 user 0.06 sys
seq_eq_parallel,4,4,4,
1.19 real 0.77 user 0.14 sys
seq_eq_parallel,4,4,5,
2.61 real 1.53 user 0.31 sys
seq_eq_parallel,4,4,6,
4.05 real 2.87 user 0.55 sys
seq_eq_parallel,4,4,7,
6.40 real 4.73 user 1.03 sys
seq_eq_parallel,4,4,8,
10.47 real 7.63 user 1.96 sys
seq_eq_parallel,4,5,2,
0.99 real 0.46 user 0.11 sys
seq_eq_parallel,4,5,3,
2.40 real 1.72 user 0.28 sys
seq_eq_parallel,4,5,4,
6.93 real 5.02 user 1.14 sys
seq_eq_parallel,4,5,5,
22.23 real 13.75 user 5.59 sys
seq_eq_parallel,4,5,6,
139.63 real 39.78 user 43.62 sys
seq_eq_parallel,5,3,2,
0.44 real 0.07 user 0.07 sys
seq_eq_parallel,5,3,3,
0.38 real 0.13 user 0.07 sys
seq_eq_parallel,5,3,4,
0.51 real 0.19 user 0.09 sys
seq_eq_parallel,5,3,5,
0.58 real 0.31 user 0.08 sys
seq_eq_parallel,5,3,6,
0.65 real 0.42 user 0.07 sys
seq_eq_parallel,5,3,7,
0.82 real 0.58 user 0.08 sys
seq_eq_parallel,5,3,8,
1.28 real 0.87 user 0.14 sys
seq_eq_parallel,5,4,2,
0.53 real 0.15 user 0.08 sys
seq_eq_parallel,5,4,3,
0.80 real 0.40 user 0.09 sys
seq_eq_parallel,5,4,4,
1.29 real 0.90 user 0.14 sys
seq_eq_parallel,5,4,5,
2.67 real 1.93 user 0.28 sys
seq_eq_parallel,5,4,6,
4.68 real 3.51 user 0.60 sys
seq_eq_parallel,5,4,7,
11.94 real 6.67 user 2.18 sys
seq_eq_parallel,5,4,8,
18.38 real 10.46 user 2.77 sys
seq_eq_parallel,5,5,2,
3.16 real 1.22 user 0.20 sys
seq_eq_parallel,5,5,3,
10.96 real 5.20 user 1.10 sys
seq_eq_parallel,5,5,4,
68.06 real 18.49 user 13.30 sys
seq_eq_parallel,6,3,2,
0.46 real 0.11 user 0.08 sys
seq_eq_parallel,6,3,3,
0.60 real 0.22 user 0.09 sys
seq_eq_parallel,6,3,4,
0.79 real 0.38 user 0.09 sys
seq_eq_parallel,6,3,5,
1.48 real 0.66 user 0.13 sys
seq_eq_parallel,6,3,6,
2.33 real 1.06 user 0.21 sys
seq_eq_parallel,6,3,7,
3.64 real 1.49 user 0.23 sys
seq_eq_parallel,6,3,8,
4.19 real 2.08 user 0.31 sys
seq_eq_parallel,6,4,2,
0.74 real 0.34 user 0.08 sys
seq_eq_parallel,6,4,3,
1.84 real 0.92 user 0.13 sys
seq_eq_parallel,6,4,4,
4.65 real 2.20 user 0.33 sys
seq_eq_parallel,6,4,5,
10.27 real 4.76 user 0.92 sys
seq_eq_parallel,6,4,6,
24.70 real 9.22 user 3.10 sys
seq_eq_parallel,6,4,7,
52.76 real 16.49 user 7.90 sys
seq_eq_parallel,6,4,8,
196.66 real 36.23 user 46.28 sys
seq_eq_parallel,6,5,2,
2.60 real 1.04 user 0.16 sys
seq_eq_parallel,6,5,3,
15.11 real 4.98 user 1.93 sys
seq_eq_parallel,6,5,4,
76.82 real 18.34 user 15.81 sys
seq_eq_parallel,7,3,2,
0.52 real 0.21 user 0.07 sys
seq_eq_parallel,7,3,3,
1.12 real 0.46 user 0.11 sys
seq_eq_parallel,7,3,4,
1.97 real 0.87 user 0.14 sys
seq_eq_parallel,7,3,5,
3.74 real 1.45 user 0.23 sys
seq_eq_parallel,7,3,6,
4.36 real 2.24 user 0.31 sys
seq_eq_parallel,7,3,7,
6.82 real 3.38 user 0.53 sys
seq_eq_parallel,7,3,8,
10.21 real 4.93 user 0.93 sys
seq_eq_parallel,7,4,2,
2.00 real 0.75 user 0.14 sys
seq_eq_parallel,7,4,3,
4.59 real 2.15 user 0.34 sys
seq_eq_parallel,7,4,4,
13.71 real 5.35 user 1.20 sys
seq_eq_parallel,7,4,5,
37.15 real 11.78 user 4.54 sys
seq_eq_parallel,7,4,6,
107.50 real 25.80 user 21.47 sys
seq_eq_parallel,7,4,7,
319.25 real 55.45 user 79.14 sys
seq_eq_parallel,8,3,2,
0.94 real 0.42 user 0.10 sys
seq_eq_parallel,8,3,3,
2.75 real 1.01 user 0.18 sys
seq_eq_parallel,8,3,4,
3.50 real 1.84 user 0.24 sys
seq_eq_parallel,8,3,5,
6.42 real 3.23 user 0.46 sys
seq_eq_parallel,8,3,6,
10.36 real 5.18 user 0.87 sys
seq_eq_parallel,8,3,7,
19.11 real 8.07 user 1.93 sys
seq_eq_parallel,8,3,8,
39.00 real 12.05 user 4.40 sys
seq_eq_parallel,8,4,2,
2.94 real 1.46 user 0.16 sys
seq_eq_parallel,8,4,3,
11.56 real 5.04 user 0.81 sys
seq_eq_parallel,8,4,4,
42.06 real 13.24 user 6.15 sys
seq_eq_parallel,8,4,5,
162.17 real 34.75 user 32.92 sys

37
ReversalModel/trace_seq_eq_parallel_2_3_2.txt Normal file
View file

@ -0,0 +1,37 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 140 byte, depth reached 141, errors: 0
2806 states, stored
270 states, matched
3076 transitions (= stored+matched)
0 atomic steps
hash conflicts: 0 (resolved)
Stats on memory usage (in Megabytes):
0.450 equivalent memory usage for states (stored*(State-vector + overhead))
0.575 actual memory usage for states
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
129.022 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_3_2.pml:87, state 71, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_3_2.pml:91, state 81, "-end-"
(2 of 81 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0 seconds

37
ReversalModel/trace_seq_eq_parallel_2_3_3.txt Normal file
View file

@ -0,0 +1,37 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 140 byte, depth reached 141, errors: 0
6612 states, stored
640 states, matched
7252 transitions (= stored+matched)
0 atomic steps
hash conflicts: 0 (resolved)
Stats on memory usage (in Megabytes):
1.059 equivalent memory usage for states (stored*(State-vector + overhead))
1.063 actual memory usage for states
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
129.511 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_3_3.pml:87, state 72, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_3_3.pml:91, state 82, "-end-"
(2 of 82 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0 seconds

38
ReversalModel/trace_seq_eq_parallel_2_3_4.txt Normal file
View file

@ -0,0 +1,38 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 140 byte, depth reached 141, errors: 0
12874 states, stored
1250 states, matched
14124 transitions (= stored+matched)
0 atomic steps
hash conflicts: 0 (resolved)
Stats on memory usage (in Megabytes):
2.063 equivalent memory usage for states (stored*(State-vector + overhead))
1.942 actual memory usage for states (compression: 94.17%)
state-vector as stored = 130 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
130.390 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_3_4.pml:87, state 73, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_3_4.pml:91, state 83, "-end-"
(2 of 83 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.01 seconds

39
ReversalModel/trace_seq_eq_parallel_2_3_5.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 140 byte, depth reached 141, errors: 0
22204 states, stored
2160 states, matched
24364 transitions (= stored+matched)
0 atomic steps
hash conflicts: 0 (resolved)
Stats on memory usage (in Megabytes):
3.557 equivalent memory usage for states (stored*(State-vector + overhead))
3.115 actual memory usage for states (compression: 87.55%)
state-vector as stored = 119 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
131.562 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_3_5.pml:87, state 74, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_3_5.pml:91, state 84, "-end-"
(2 of 84 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.02 seconds
pan: rate 1110200 states/second

39
ReversalModel/trace_seq_eq_parallel_2_3_6.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 140 byte, depth reached 141, errors: 0
35214 states, stored
3430 states, matched
38644 transitions (= stored+matched)
0 atomic steps
hash conflicts: 3 (resolved)
Stats on memory usage (in Megabytes):
5.642 equivalent memory usage for states (stored*(State-vector + overhead))
4.873 actual memory usage for states (compression: 86.38%)
state-vector as stored = 117 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
133.319 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_3_6.pml:87, state 75, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_3_6.pml:91, state 85, "-end-"
(2 of 85 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.03 seconds
pan: rate 1173800 states/second

39
ReversalModel/trace_seq_eq_parallel_2_3_7.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 140 byte, depth reached 141, errors: 0
52516 states, stored
5120 states, matched
57636 transitions (= stored+matched)
0 atomic steps
hash conflicts: 2 (resolved)
Stats on memory usage (in Megabytes):
8.414 equivalent memory usage for states (stored*(State-vector + overhead))
7.121 actual memory usage for states (compression: 84.63%)
state-vector as stored = 114 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
135.565 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_3_7.pml:87, state 76, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_3_7.pml:91, state 86, "-end-"
(2 of 86 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.04 seconds
pan: rate 1312900 states/second

39
ReversalModel/trace_seq_eq_parallel_2_3_8.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 140 byte, depth reached 141, errors: 0
74722 states, stored
7290 states, matched
82012 transitions (= stored+matched)
0 atomic steps
hash conflicts: 9 (resolved)
Stats on memory usage (in Megabytes):
11.972 equivalent memory usage for states (stored*(State-vector + overhead))
10.052 actual memory usage for states (compression: 83.96%)
state-vector as stored = 113 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
138.495 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_3_8.pml:87, state 77, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_3_8.pml:91, state 87, "-end-"
(2 of 87 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.06 seconds
pan: rate 1245366.7 states/second

38
ReversalModel/trace_seq_eq_parallel_2_4_2.txt Normal file
View file

@ -0,0 +1,38 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 156 byte, depth reached 161, errors: 0
10123 states, stored
1053 states, matched
11176 transitions (= stored+matched)
0 atomic steps
hash conflicts: 0 (resolved)
Stats on memory usage (in Megabytes):
1.776 equivalent memory usage for states (stored*(State-vector + overhead))
1.650 actual memory usage for states (compression: 92.86%)
state-vector as stored = 143 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
130.097 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_4_2.pml:87, state 71, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_4_2.pml:91, state 81, "-end-"
(2 of 81 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.01 seconds

39
ReversalModel/trace_seq_eq_parallel_2_4_3.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 156 byte, depth reached 161, errors: 0
31828 states, stored
3328 states, matched
35156 transitions (= stored+matched)
0 atomic steps
hash conflicts: 4 (resolved)
Stats on memory usage (in Megabytes):
5.585 equivalent memory usage for states (stored*(State-vector + overhead))
4.776 actual memory usage for states (compression: 85.52%)
state-vector as stored = 129 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
133.222 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_4_3.pml:87, state 72, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_4_3.pml:91, state 82, "-end-"
(2 of 82 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.03 seconds
pan: rate 1060933.3 states/second

39
ReversalModel/trace_seq_eq_parallel_2_4_4.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 156 byte, depth reached 161, errors: 0
77499 states, stored
8125 states, matched
85624 transitions (= stored+matched)
0 atomic steps
hash conflicts: 7 (resolved)
Stats on memory usage (in Megabytes):
13.599 equivalent memory usage for states (stored*(State-vector + overhead))
11.226 actual memory usage for states (compression: 82.55%)
state-vector as stored = 124 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
139.667 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_4_4.pml:87, state 73, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_4_4.pml:91, state 83, "-end-"
(2 of 83 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.07 seconds
pan: rate 1107128.6 states/second

39
ReversalModel/trace_seq_eq_parallel_2_4_5.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 156 byte, depth reached 161, errors: 0
160444 states, stored
16848 states, matched
177292 transitions (= stored+matched)
0 atomic steps
hash conflicts: 34 (resolved)
Stats on memory usage (in Megabytes):
28.154 equivalent memory usage for states (stored*(State-vector + overhead))
23.051 actual memory usage for states (compression: 81.87%)
state-vector as stored = 123 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
151.483 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_4_5.pml:87, state 74, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_4_5.pml:91, state 84, "-end-"
(2 of 84 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.14 seconds
pan: rate 1146028.6 states/second

39
ReversalModel/trace_seq_eq_parallel_2_4_6.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 156 byte, depth reached 161, errors: 0
296923 states, stored
31213 states, matched
328136 transitions (= stored+matched)
0 atomic steps
hash conflicts: 96 (resolved)
Stats on memory usage (in Megabytes):
52.103 equivalent memory usage for states (stored*(State-vector + overhead))
42.400 actual memory usage for states (compression: 81.38%)
state-vector as stored = 122 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
170.819 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_4_6.pml:87, state 75, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_4_6.pml:91, state 85, "-end-"
(2 of 85 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.26 seconds
pan: rate 1142011.5 states/second

39
ReversalModel/trace_seq_eq_parallel_2_4_7.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 156 byte, depth reached 161, errors: 0
506148 states, stored
53248 states, matched
559396 transitions (= stored+matched)
0 atomic steps
hash conflicts: 294 (resolved)
Stats on memory usage (in Megabytes):
88.817 equivalent memory usage for states (stored*(State-vector + overhead))
72.105 actual memory usage for states (compression: 81.18%)
state-vector as stored = 121 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
200.507 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_4_7.pml:87, state 76, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_4_7.pml:91, state 86, "-end-"
(2 of 86 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.47 seconds
pan: rate 1076910.6 states/second

39
ReversalModel/trace_seq_eq_parallel_2_4_8.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 156 byte, depth reached 161, errors: 0
810283 states, stored
85293 states, matched
895576 transitions (= stored+matched)
0 atomic steps
hash conflicts: 783 (resolved)
Stats on memory usage (in Megabytes):
142.185 equivalent memory usage for states (stored*(State-vector + overhead))
115.295 actual memory usage for states (compression: 81.09%)
state-vector as stored = 121 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
243.671 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_4_8.pml:87, state 77, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_4_8.pml:91, state 87, "-end-"
(2 of 87 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.7 seconds
pan: rate 1157547.1 states/second

39
ReversalModel/trace_seq_eq_parallel_2_5_2.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 164 byte, depth reached 181, errors: 0
36448 states, stored
4131 states, matched
40579 transitions (= stored+matched)
0 atomic steps
hash conflicts: 5 (resolved)
Stats on memory usage (in Megabytes):
6.674 equivalent memory usage for states (stored*(State-vector + overhead))
5.949 actual memory usage for states (compression: 89.13%)
state-vector as stored = 143 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
134.394 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_5_2.pml:87, state 71, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_5_2.pml:91, state 81, "-end-"
(2 of 81 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.03 seconds
pan: rate 1214933.3 states/second

39
ReversalModel/trace_seq_eq_parallel_2_5_3.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 164 byte, depth reached 181, errors: 0
152916 states, stored
17408 states, matched
170324 transitions (= stored+matched)
0 atomic steps
hash conflicts: 23 (resolved)
Stats on memory usage (in Megabytes):
28.000 equivalent memory usage for states (stored*(State-vector + overhead))
24.121 actual memory usage for states (compression: 86.15%)
state-vector as stored = 137 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
152.558 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_5_3.pml:87, state 72, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_5_3.pml:91, state 82, "-end-"
(2 of 82 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.14 seconds
pan: rate 1092257.1 states/second

39
ReversalModel/trace_seq_eq_parallel_2_5_4.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 164 byte, depth reached 181, errors: 0
465624 states, stored
53125 states, matched
518749 transitions (= stored+matched)
0 atomic steps
hash conflicts: 258 (resolved)
Stats on memory usage (in Megabytes):
85.258 equivalent memory usage for states (stored*(State-vector + overhead))
73.072 actual memory usage for states (compression: 85.71%)
state-vector as stored = 137 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
201.483 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_5_4.pml:87, state 73, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_5_4.pml:91, state 83, "-end-"
(2 of 83 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.44 seconds
pan: rate 1058236.4 states/second

40
ReversalModel/trace_seq_eq_parallel_2_5_5.txt Normal file
View file

@ -0,0 +1,40 @@
pan: ltl formula seq_eq_parallel
Depth= 181 States= 1e+06 Transitions= 1.11e+06 Memory= 284.980 t= 0.94 R= 1e+06
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 164 byte, depth reached 181, errors: 0
1157068 states, stored
132192 states, matched
1289260 transitions (= stored+matched)
0 atomic steps
hash conflicts: 1840 (resolved)
Stats on memory usage (in Megabytes):
211.865 equivalent memory usage for states (stored*(State-vector + overhead))
181.210 actual memory usage for states (compression: 85.53%)
state-vector as stored = 136 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
309.589 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_5_5.pml:87, state 74, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_5_5.pml:91, state 84, "-end-"
(2 of 84 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 1.09 seconds
pan: rate 1061530.3 states/second

41
ReversalModel/trace_seq_eq_parallel_2_5_6.txt Normal file
View file

@ -0,0 +1,41 @@
pan: ltl formula seq_eq_parallel
Depth= 181 States= 1e+06 Transitions= 1.11e+06 Memory= 285.077 t= 0.99 R= 1e+06
Depth= 181 States= 2e+06 Transitions= 2.23e+06 Memory= 441.425 t= 1.97 R= 1e+06
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 164 byte, depth reached 181, errors: 0
2498640 states, stored
285719 states, matched
2784359 transitions (= stored+matched)
0 atomic steps
hash conflicts: 10810 (resolved)
Stats on memory usage (in Megabytes):
457.515 equivalent memory usage for states (stored*(State-vector + overhead))
391.111 actual memory usage for states (compression: 85.49%)
state-vector as stored = 136 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
519.355 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_5_6.pml:87, state 75, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_5_6.pml:91, state 85, "-end-"
(2 of 85 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 2.52 seconds
pan: rate 991523.81 states/second

43
ReversalModel/trace_seq_eq_parallel_2_5_7.txt Normal file
View file

@ -0,0 +1,43 @@
pan: ltl formula seq_eq_parallel
Depth= 181 States= 1e+06 Transitions= 1.11e+06 Memory= 285.077 t= 1.06 R= 9e+05
Depth= 181 States= 2e+06 Transitions= 2.23e+06 Memory= 441.425 t= 2.12 R= 9e+05
Depth= 181 States= 3e+06 Transitions= 3.34e+06 Memory= 597.772 t= 3.18 R= 9e+05
Depth= 181 States= 4e+06 Transitions= 4.46e+06 Memory= 754.218 t= 4.23 R= 9e+05
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 164 byte, depth reached 181, errors: 0
4868388 states, stored
557056 states, matched
5425444 transitions (= stored+matched)
0 atomic steps
hash conflicts: 56101 (resolved)
Stats on memory usage (in Megabytes):
891.428 equivalent memory usage for states (stored*(State-vector + overhead))
761.902 actual memory usage for states (compression: 85.47%)
state-vector as stored = 136 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
889.960 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_5_7.pml:87, state 76, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_5_7.pml:91, state 86, "-end-"
(2 of 86 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 5.11 seconds
pan: rate 952717.81 states/second

47
ReversalModel/trace_seq_eq_parallel_2_5_8.txt Normal file
View file

@ -0,0 +1,47 @@
pan: ltl formula seq_eq_parallel
Depth= 181 States= 1e+06 Transitions= 1.11e+06 Memory= 285.077 t= 1.07 R= 9e+05
Depth= 181 States= 2e+06 Transitions= 2.23e+06 Memory= 441.425 t= 2.01 R= 1e+06
Depth= 181 States= 3e+06 Transitions= 3.34e+06 Memory= 597.870 t= 2.95 R= 1e+06
Depth= 181 States= 4e+06 Transitions= 4.46e+06 Memory= 754.218 t= 3.91 R= 1e+06
Depth= 181 States= 5e+06 Transitions= 5.57e+06 Memory= 910.663 t= 4.87 R= 1e+06
Depth= 181 States= 6e+06 Transitions= 6.69e+06 Memory= 1067.011 t= 5.88 R= 1e+06
Depth= 181 States= 7e+06 Transitions= 7.8e+06 Memory= 1223.456 t= 6.88 R= 1e+06
Depth= 181 States= 8e+06 Transitions= 8.92e+06 Memory= 1379.804 t= 7.88 R= 1e+06
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 164 byte, depth reached 181, errors: 0
8768776 states, stored
1003833 states, matched
9772609 transitions (= stored+matched)
0 atomic steps
hash conflicts: 256903 (resolved)
Stats on memory usage (in Megabytes):
1605.611 equivalent memory usage for states (stored*(State-vector + overhead))
1372.383 actual memory usage for states (compression: 85.47%)
state-vector as stored = 136 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
1500.116 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_5_8.pml:87, state 77, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_5_8.pml:91, state 87, "-end-"
(2 of 87 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 8.66 seconds
pan: rate 1012560.7 states/second

39
ReversalModel/trace_seq_eq_parallel_2_6_2.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 180 byte, depth reached 201, errors: 0
128302 states, stored
15309 states, matched
143611 transitions (= stored+matched)
0 atomic steps
hash conflicts: 16 (resolved)
Stats on memory usage (in Megabytes):
25.451 equivalent memory usage for states (stored*(State-vector + overhead))
21.588 actual memory usage for states (compression: 84.82%)
state-vector as stored = 148 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
150.019 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_6_2.pml:87, state 71, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_6_2.pml:91, state 81, "-end-"
(2 of 81 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.13 seconds
pan: rate 986938.46 states/second

39
ReversalModel/trace_seq_eq_parallel_2_6_3.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 180 byte, depth reached 201, errors: 0
718164 states, stored
86016 states, matched
804180 transitions (= stored+matched)
0 atomic steps
hash conflicts: 680 (resolved)
Stats on memory usage (in Megabytes):
142.458 equivalent memory usage for states (stored*(State-vector + overhead))
120.010 actual memory usage for states (compression: 84.24%)
state-vector as stored = 147 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
248.358 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_6_3.pml:87, state 72, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_6_3.pml:91, state 82, "-end-"
(2 of 82 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.71 seconds
pan: rate 1011498.6 states/second

41
ReversalModel/trace_seq_eq_parallel_2_6_4.txt Normal file
View file

@ -0,0 +1,41 @@
pan: ltl formula seq_eq_parallel
Depth= 201 States= 1e+06 Transitions= 1.12e+06 Memory= 295.331 t= 0.99 R= 1e+06
Depth= 201 States= 2e+06 Transitions= 2.24e+06 Memory= 461.933 t= 2.04 R= 1e+06
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 180 byte, depth reached 201, errors: 0
2734374 states, stored
328125 states, matched
3062499 transitions (= stored+matched)
0 atomic steps
hash conflicts: 13681 (resolved)
Stats on memory usage (in Megabytes):
542.402 equivalent memory usage for states (stored*(State-vector + overhead))
456.250 actual memory usage for states (compression: 84.12%)
state-vector as stored = 147 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
584.296 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_6_4.pml:87, state 73, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_6_4.pml:91, state 83, "-end-"
(2 of 83 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 2.77 seconds
pan: rate 987138.63 states/second

48
ReversalModel/trace_seq_eq_parallel_2_6_5.txt Normal file
View file

@ -0,0 +1,48 @@
pan: ltl formula seq_eq_parallel
Depth= 201 States= 1e+06 Transitions= 1.12e+06 Memory= 295.331 t= 0.99 R= 1e+06
Depth= 201 States= 2e+06 Transitions= 2.24e+06 Memory= 462.030 t= 1.98 R= 1e+06
Depth= 201 States= 3e+06 Transitions= 3.36e+06 Memory= 628.730 t= 3.03 R= 1e+06
Depth= 201 States= 4e+06 Transitions= 4.48e+06 Memory= 795.331 t= 4.05 R= 1e+06
Depth= 201 States= 5e+06 Transitions= 5.6e+06 Memory= 962.030 t= 5.1 R= 1e+06
Depth= 201 States= 6e+06 Transitions= 6.72e+06 Memory= 1128.730 t= 6.14 R= 1e+06
Depth= 201 States= 7e+06 Transitions= 7.84e+06 Memory= 1295.331 t= 7.2 R= 1e+06
Depth= 201 States= 8e+06 Transitions= 8.96e+06 Memory= 1462.030 t= 8.27 R= 1e+06
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 180 byte, depth reached 201, errors: 0
8155468 states, stored
979776 states, matched
9135244 transitions (= stored+matched)
0 atomic steps
hash conflicts: 210441 (resolved)
Stats on memory usage (in Megabytes):
1617.753 equivalent memory usage for states (stored*(State-vector + overhead))
1360.792 actual memory usage for states (compression: 84.12%)
state-vector as stored = 147 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
1.319 memory lost to fragmentation
1488.007 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_6_5.pml:87, state 74, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_6_5.pml:91, state 84, "-end-"
(2 of 84 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 8.45 seconds
pan: rate 965144.14 states/second

60
ReversalModel/trace_seq_eq_parallel_2_6_6.txt Normal file
View file

@ -0,0 +1,60 @@
pan: ltl formula seq_eq_parallel
Depth= 201 States= 1e+06 Transitions= 1.12e+06 Memory= 295.331 t= 1.12 R= 9e+05
Depth= 201 States= 2e+06 Transitions= 2.24e+06 Memory= 462.030 t= 2.25 R= 9e+05
Depth= 201 States= 3e+06 Transitions= 3.36e+06 Memory= 628.730 t= 3.29 R= 9e+05
Depth= 201 States= 4e+06 Transitions= 4.48e+06 Memory= 795.429 t= 4.32 R= 9e+05
Depth= 201 States= 5e+06 Transitions= 5.6e+06 Memory= 962.128 t= 5.4 R= 9e+05
Depth= 201 States= 6e+06 Transitions= 6.72e+06 Memory= 1128.827 t= 6.5 R= 9e+05
Depth= 201 States= 7e+06 Transitions= 7.84e+06 Memory= 1295.526 t= 7.82 R= 9e+05
Depth= 201 States= 8e+06 Transitions= 8.96e+06 Memory= 1462.226 t= 8.94 R= 9e+05
Depth= 201 States= 9e+06 Transitions= 1.01e+07 Memory= 1628.925 t= 10.1 R= 9e+05
Depth= 201 States= 1e+07 Transitions= 1.12e+07 Memory= 1795.624 t= 11.3 R= 9e+05
Depth= 201 States= 1.1e+07 Transitions= 1.23e+07 Memory= 1962.323 t= 12.5 R= 9e+05
Depth= 201 States= 1.2e+07 Transitions= 1.34e+07 Memory= 2129.022 t= 13.7 R= 9e+05
Depth= 201 States= 1.3e+07 Transitions= 1.46e+07 Memory= 2295.722 t= 14.9 R= 9e+05
Depth= 201 States= 1.4e+07 Transitions= 1.57e+07 Memory= 2462.421 t= 16.2 R= 9e+05
Depth= 201 States= 1.5e+07 Transitions= 1.68e+07 Memory= 2629.120 t= 17.4 R= 9e+05
Depth= 201 States= 1.6e+07 Transitions= 1.79e+07 Memory= 2795.819 t= 18.7 R= 9e+05
Depth= 201 States= 1.7e+07 Transitions= 1.9e+07 Memory= 2962.519 t= 20 R= 9e+05
Depth= 201 States= 1.8e+07 Transitions= 2.02e+07 Memory= 3129.218 t= 21.2 R= 8e+05
Depth= 201 States= 1.9e+07 Transitions= 2.13e+07 Memory= 3295.917 t= 22.5 R= 8e+05
Depth= 201 States= 2e+07 Transitions= 2.24e+07 Memory= 3462.616 t= 23.8 R= 8e+05
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 180 byte, depth reached 201, errors: 0
20549358 states, stored
2470629 states, matched
23019987 transitions (= stored+matched)
0 atomic steps
hash conflicts: 2325067 (resolved)
Stats on memory usage (in Megabytes):
4076.258 equivalent memory usage for states (stored*(State-vector + overhead))
3428.943 actual memory usage for states (compression: 84.12%)
state-vector as stored = 147 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
3.357 memory lost to fragmentation
3554.120 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_6_6.pml:87, state 75, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_6_6.pml:91, state 85, "-end-"
(2 of 85 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 24.4 seconds
pan: rate 840808.43 states/second

86
ReversalModel/trace_seq_eq_parallel_2_6_7.txt Normal file
View file

@ -0,0 +1,86 @@
pan: ltl formula seq_eq_parallel
Depth= 201 States= 1e+06 Transitions= 1.12e+06 Memory= 295.429 t= 1.03 R= 1e+06
Depth= 201 States= 2e+06 Transitions= 2.24e+06 Memory= 462.128 t= 2.1 R= 1e+06
Depth= 201 States= 3e+06 Transitions= 3.36e+06 Memory= 628.827 t= 3.17 R= 9e+05
Depth= 201 States= 4e+06 Transitions= 4.48e+06 Memory= 795.526 t= 4.23 R= 9e+05
Depth= 201 States= 5e+06 Transitions= 5.6e+06 Memory= 962.226 t= 5.33 R= 9e+05
Depth= 201 States= 6e+06 Transitions= 6.72e+06 Memory= 1128.925 t= 6.51 R= 9e+05
Depth= 201 States= 7e+06 Transitions= 7.84e+06 Memory= 1295.624 t= 7.73 R= 9e+05
Depth= 201 States= 8e+06 Transitions= 8.96e+06 Memory= 1462.323 t= 8.82 R= 9e+05
Depth= 201 States= 9e+06 Transitions= 1.01e+07 Memory= 1629.022 t= 9.96 R= 9e+05
Depth= 201 States= 1e+07 Transitions= 1.12e+07 Memory= 1795.819 t= 11.1 R= 9e+05
Depth= 201 States= 1.1e+07 Transitions= 1.23e+07 Memory= 1962.519 t= 12.3 R= 9e+05
Depth= 201 States= 1.2e+07 Transitions= 1.34e+07 Memory= 2129.218 t= 13.5 R= 9e+05
Depth= 201 States= 1.3e+07 Transitions= 1.46e+07 Memory= 2295.917 t= 14.7 R= 9e+05
Depth= 201 States= 1.4e+07 Transitions= 1.57e+07 Memory= 2462.616 t= 16 R= 9e+05
Depth= 201 States= 1.5e+07 Transitions= 1.68e+07 Memory= 2629.315 t= 17.2 R= 9e+05
Depth= 201 States= 1.6e+07 Transitions= 1.79e+07 Memory= 2796.015 t= 18.5 R= 9e+05
Depth= 201 States= 1.7e+07 Transitions= 1.9e+07 Memory= 2962.714 t= 19.8 R= 9e+05
Depth= 201 States= 1.8e+07 Transitions= 2.02e+07 Memory= 3129.413 t= 21.1 R= 9e+05
Depth= 201 States= 1.9e+07 Transitions= 2.13e+07 Memory= 3296.112 t= 22.3 R= 9e+05
Depth= 201 States= 2e+07 Transitions= 2.24e+07 Memory= 3462.909 t= 23.6 R= 8e+05
Depth= 201 States= 2.1e+07 Transitions= 2.35e+07 Memory= 3629.608 t= 24.9 R= 8e+05
Depth= 201 States= 2.2e+07 Transitions= 2.46e+07 Memory= 3796.308 t= 26.3 R= 8e+05
Depth= 201 States= 2.3e+07 Transitions= 2.58e+07 Memory= 3963.007 t= 27.7 R= 8e+05
Depth= 201 States= 2.4e+07 Transitions= 2.69e+07 Memory= 4129.706 t= 29.1 R= 8e+05
Depth= 201 States= 2.5e+07 Transitions= 2.8e+07 Memory= 4296.405 t= 30.4 R= 8e+05
Depth= 201 States= 2.6e+07 Transitions= 2.91e+07 Memory= 4463.105 t= 31.8 R= 8e+05
Depth= 201 States= 2.7e+07 Transitions= 3.02e+07 Memory= 4629.804 t= 33.1 R= 8e+05
Depth= 201 States= 2.8e+07 Transitions= 3.14e+07 Memory= 4796.503 t= 34.5 R= 8e+05
Depth= 201 States= 2.9e+07 Transitions= 3.25e+07 Memory= 4963.202 t= 35.9 R= 8e+05
Depth= 201 States= 3e+07 Transitions= 3.36e+07 Memory= 5129.999 t= 37.3 R= 8e+05
Depth= 201 States= 3.1e+07 Transitions= 3.47e+07 Memory= 5296.698 t= 38.7 R= 8e+05
Depth= 201 States= 3.2e+07 Transitions= 3.58e+07 Memory= 5463.397 t= 40.1 R= 8e+05
Depth= 201 States= 3.3e+07 Transitions= 3.7e+07 Memory= 5630.097 t= 41.5 R= 8e+05
Depth= 201 States= 3.4e+07 Transitions= 3.81e+07 Memory= 5796.796 t= 42.9 R= 8e+05
pan: resizing hashtable to -w26.. done
Depth= 201 States= 3.5e+07 Transitions= 3.92e+07 Memory= 6459.577 t= 50.1 R= 7e+05
Depth= 201 States= 3.6e+07 Transitions= 4.03e+07 Memory= 6626.276 t= 51.4 R= 7e+05
Depth= 201 States= 3.7e+07 Transitions= 4.15e+07 Memory= 6792.976 t= 52.6 R= 7e+05
Depth= 201 States= 3.8e+07 Transitions= 4.26e+07 Memory= 6959.675 t= 53.7 R= 7e+05
Depth= 201 States= 3.9e+07 Transitions= 4.37e+07 Memory= 7126.374 t= 54.9 R= 7e+05
Depth= 201 States= 4e+07 Transitions= 4.48e+07 Memory= 7293.073 t= 56.1 R= 7e+05
Depth= 201 States= 4.1e+07 Transitions= 4.59e+07 Memory= 7459.772 t= 57.3 R= 7e+05
Depth= 201 States= 4.2e+07 Transitions= 4.71e+07 Memory= 7626.472 t= 58.5 R= 7e+05
Depth= 201 States= 4.3e+07 Transitions= 4.82e+07 Memory= 7793.171 t= 59.7 R= 7e+05
Depth= 201 States= 4.4e+07 Transitions= 4.93e+07 Memory= 7959.870 t= 61 R= 7e+05
Depth= 201 States= 4.5e+07 Transitions= 5.04e+07 Memory= 8126.667 t= 62.2 R= 7e+05
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 180 byte, depth reached 201, errors: 0
45762852 states, stored
5505024 states, matched
51267876 transitions (= stored+matched)
0 atomic steps
hash conflicts: 9411964 (resolved)
Stats on memory usage (in Megabytes):
9077.714 equivalent memory usage for states (stored*(State-vector + overhead))
7748.771 actual memory usage for states (compression: 85.36%)
state-vector as stored = 150 byte + 28 byte overhead
512.000 memory used for hash table (-w26)
0.534 memory used for DFS stack (-m10000)
7.490 memory lost to fragmentation
8253.815 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_6_7.pml:87, state 76, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_6_7.pml:91, state 86, "-end-"
(2 of 86 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 63.1 seconds
pan: rate 724783.85 states/second

133
ReversalModel/trace_seq_eq_parallel_2_6_8.txt Normal file
View file

@ -0,0 +1,133 @@
pan: ltl formula seq_eq_parallel
Depth= 201 States= 1e+06 Transitions= 1.12e+06 Memory= 295.429 t= 1.03 R= 1e+06
Depth= 201 States= 2e+06 Transitions= 2.24e+06 Memory= 462.128 t= 2.08 R= 1e+06
Depth= 201 States= 3e+06 Transitions= 3.36e+06 Memory= 628.827 t= 3.1 R= 1e+06
Depth= 201 States= 4e+06 Transitions= 4.48e+06 Memory= 795.526 t= 4.2 R= 1e+06
Depth= 201 States= 5e+06 Transitions= 5.6e+06 Memory= 962.226 t= 5.23 R= 1e+06
Depth= 201 States= 6e+06 Transitions= 6.72e+06 Memory= 1129.022 t= 6.28 R= 1e+06
Depth= 201 States= 7e+06 Transitions= 7.84e+06 Memory= 1295.722 t= 7.34 R= 1e+06
Depth= 201 States= 8e+06 Transitions= 8.96e+06 Memory= 1462.421 t= 8.42 R= 1e+06
Depth= 201 States= 9e+06 Transitions= 1.01e+07 Memory= 1629.120 t= 9.51 R= 9e+05
Depth= 201 States= 1e+07 Transitions= 1.12e+07 Memory= 1795.819 t= 10.6 R= 9e+05
Depth= 201 States= 1.1e+07 Transitions= 1.23e+07 Memory= 1962.519 t= 11.7 R= 9e+05
Depth= 201 States= 1.2e+07 Transitions= 1.34e+07 Memory= 2129.315 t= 12.9 R= 9e+05
Depth= 201 States= 1.3e+07 Transitions= 1.46e+07 Memory= 2296.015 t= 14.1 R= 9e+05
Depth= 201 States= 1.4e+07 Transitions= 1.57e+07 Memory= 2462.714 t= 15.2 R= 9e+05
Depth= 201 States= 1.5e+07 Transitions= 1.68e+07 Memory= 2629.413 t= 16.4 R= 9e+05
Depth= 201 States= 1.6e+07 Transitions= 1.79e+07 Memory= 2796.112 t= 17.6 R= 9e+05
Depth= 201 States= 1.7e+07 Transitions= 1.9e+07 Memory= 2962.812 t= 18.8 R= 9e+05
Depth= 201 States= 1.8e+07 Transitions= 2.02e+07 Memory= 3129.608 t= 20.1 R= 9e+05
Depth= 201 States= 1.9e+07 Transitions= 2.13e+07 Memory= 3296.308 t= 21.6 R= 9e+05
Depth= 201 States= 2e+07 Transitions= 2.24e+07 Memory= 3463.007 t= 22.9 R= 9e+05
Depth= 201 States= 2.1e+07 Transitions= 2.35e+07 Memory= 3629.706 t= 24.4 R= 9e+05
Depth= 201 States= 2.2e+07 Transitions= 2.46e+07 Memory= 3796.405 t= 25.8 R= 9e+05
Depth= 201 States= 2.3e+07 Transitions= 2.58e+07 Memory= 3963.202 t= 27 R= 9e+05
Depth= 201 States= 2.4e+07 Transitions= 2.69e+07 Memory= 4129.901 t= 28.3 R= 8e+05
Depth= 201 States= 2.5e+07 Transitions= 2.8e+07 Memory= 4296.601 t= 29.6 R= 8e+05
Depth= 201 States= 2.6e+07 Transitions= 2.91e+07 Memory= 4463.300 t= 31 R= 8e+05
Depth= 201 States= 2.7e+07 Transitions= 3.02e+07 Memory= 4629.999 t= 32.4 R= 8e+05
Depth= 201 States= 2.8e+07 Transitions= 3.14e+07 Memory= 4796.698 t= 33.8 R= 8e+05
Depth= 201 States= 2.9e+07 Transitions= 3.25e+07 Memory= 4963.495 t= 35.2 R= 8e+05
Depth= 201 States= 3e+07 Transitions= 3.36e+07 Memory= 5130.194 t= 36.7 R= 8e+05
Depth= 201 States= 3.1e+07 Transitions= 3.47e+07 Memory= 5296.894 t= 38.2 R= 8e+05
Depth= 201 States= 3.2e+07 Transitions= 3.59e+07 Memory= 5463.593 t= 39.7 R= 8e+05
Depth= 201 States= 3.3e+07 Transitions= 3.7e+07 Memory= 5630.292 t= 41.1 R= 8e+05
Depth= 201 States= 3.4e+07 Transitions= 3.81e+07 Memory= 5796.991 t= 42.7 R= 8e+05
pan: resizing hashtable to -w26.. done
Depth= 201 States= 3.5e+07 Transitions= 3.92e+07 Memory= 6459.772 t= 50.2 R= 7e+05
Depth= 201 States= 3.6e+07 Transitions= 4.03e+07 Memory= 6626.472 t= 51.4 R= 7e+05
Depth= 201 States= 3.7e+07 Transitions= 4.15e+07 Memory= 6793.171 t= 52.7 R= 7e+05
Depth= 201 States= 3.8e+07 Transitions= 4.26e+07 Memory= 6959.870 t= 54 R= 7e+05
Depth= 201 States= 3.9e+07 Transitions= 4.37e+07 Memory= 7126.569 t= 55.3 R= 7e+05
Depth= 201 States= 4e+07 Transitions= 4.48e+07 Memory= 7293.366 t= 56.5 R= 7e+05
Depth= 201 States= 4.1e+07 Transitions= 4.59e+07 Memory= 7460.065 t= 57.9 R= 7e+05
Depth= 201 States= 4.2e+07 Transitions= 4.71e+07 Memory= 7626.765 t= 59.3 R= 7e+05
Depth= 201 States= 4.3e+07 Transitions= 4.82e+07 Memory= 7793.464 t= 60.8 R= 7e+05
Depth= 201 States= 4.4e+07 Transitions= 4.93e+07 Memory= 7960.163 t= 62.3 R= 7e+05
Depth= 201 States= 4.5e+07 Transitions= 5.04e+07 Memory= 8126.862 t= 63.9 R= 7e+05
Depth= 201 States= 4.6e+07 Transitions= 5.15e+07 Memory= 8293.659 t= 65.7 R= 7e+05
Depth= 201 States= 4.7e+07 Transitions= 5.27e+07 Memory= 8460.358 t= 67.4 R= 7e+05
Depth= 201 States= 4.8e+07 Transitions= 5.38e+07 Memory= 8627.058 t= 69.1 R= 7e+05
Depth= 201 States= 4.9e+07 Transitions= 5.49e+07 Memory= 8793.757 t= 70.8 R= 7e+05
Depth= 201 States= 5e+07 Transitions= 5.6e+07 Memory= 8960.456 t= 72.4 R= 7e+05
Depth= 201 States= 5.1e+07 Transitions= 5.71e+07 Memory= 9127.155 t= 74.1 R= 7e+05
Depth= 201 States= 5.2e+07 Transitions= 5.83e+07 Memory= 9293.952 t= 75.9 R= 7e+05
Depth= 201 States= 5.3e+07 Transitions= 5.94e+07 Memory= 9460.651 t= 77.6 R= 7e+05
Depth= 201 States= 5.4e+07 Transitions= 6.05e+07 Memory= 9627.351 t= 79.5 R= 7e+05
Depth= 201 States= 5.5e+07 Transitions= 6.16e+07 Memory= 9794.050 t= 81.4 R= 7e+05
Depth= 201 States= 5.6e+07 Transitions= 6.27e+07 Memory= 9960.749 t= 83.1 R= 7e+05
Depth= 201 States= 5.7e+07 Transitions= 6.39e+07 Memory= 10127.448 t= 84.9 R= 7e+05
Depth= 201 States= 5.8e+07 Transitions= 6.5e+07 Memory= 10294.245 t= 86.6 R= 7e+05
Depth= 201 States= 5.9e+07 Transitions= 6.61e+07 Memory= 10460.944 t= 88.4 R= 7e+05
Depth= 201 States= 6e+07 Transitions= 6.72e+07 Memory= 10627.644 t= 90.3 R= 7e+05
Depth= 201 States= 6.1e+07 Transitions= 6.83e+07 Memory= 10794.343 t= 92.1 R= 7e+05
Depth= 201 States= 6.2e+07 Transitions= 6.95e+07 Memory= 10961.042 t= 93.7 R= 7e+05
Depth= 201 States= 6.3e+07 Transitions= 7.06e+07 Memory= 11127.839 t= 95.5 R= 7e+05
Depth= 201 States= 6.4e+07 Transitions= 7.17e+07 Memory= 11294.538 t= 97.5 R= 7e+05
Depth= 201 States= 6.5e+07 Transitions= 7.28e+07 Memory= 11461.237 t= 99.5 R= 7e+05
Depth= 201 States= 6.6e+07 Transitions= 7.39e+07 Memory= 11627.937 t= 101 R= 7e+05
Depth= 201 States= 6.7e+07 Transitions= 7.51e+07 Memory= 11794.636 t= 104 R= 6e+05
Depth= 201 States= 6.8e+07 Transitions= 7.62e+07 Memory= 11961.335 t= 106 R= 6e+05
Depth= 201 States= 6.9e+07 Transitions= 7.73e+07 Memory= 12128.132 t= 109 R= 6e+05
Depth= 201 States= 7e+07 Transitions= 7.84e+07 Memory= 12294.831 t= 113 R= 6e+05
Depth= 201 States= 7.1e+07 Transitions= 7.95e+07 Memory= 12461.530 t= 117 R= 6e+05
Depth= 201 States= 7.2e+07 Transitions= 8.07e+07 Memory= 12628.230 t= 121 R= 6e+05
Depth= 201 States= 7.3e+07 Transitions= 8.18e+07 Memory= 12794.929 t= 125 R= 6e+05
Depth= 201 States= 7.4e+07 Transitions= 8.29e+07 Memory= 12961.628 t= 130 R= 6e+05
Depth= 201 States= 7.5e+07 Transitions= 8.4e+07 Memory= 13128.425 t= 136 R= 6e+05
Depth= 201 States= 7.6e+07 Transitions= 8.51e+07 Memory= 13295.124 t= 141 R= 5e+05
Depth= 201 States= 7.7e+07 Transitions= 8.63e+07 Memory= 13461.823 t= 148 R= 5e+05
Depth= 201 States= 7.8e+07 Transitions= 8.74e+07 Memory= 13628.522 t= 155 R= 5e+05
Depth= 201 States= 7.9e+07 Transitions= 8.85e+07 Memory= 13795.222 t= 162 R= 5e+05
Depth= 201 States= 8e+07 Transitions= 8.96e+07 Memory= 13961.921 t= 170 R= 5e+05
Depth= 201 States= 8.1e+07 Transitions= 9.07e+07 Memory= 14128.718 t= 178 R= 5e+05
Depth= 201 States= 8.2e+07 Transitions= 9.19e+07 Memory= 14295.417 t= 186 R= 4e+05
Depth= 201 States= 8.3e+07 Transitions= 9.3e+07 Memory= 14462.116 t= 196 R= 4e+05
Depth= 201 States= 8.4e+07 Transitions= 9.41e+07 Memory= 14628.815 t= 205 R= 4e+05
Depth= 201 States= 8.5e+07 Transitions= 9.52e+07 Memory= 14795.515 t= 215 R= 4e+05
Depth= 201 States= 8.6e+07 Transitions= 9.63e+07 Memory= 14962.214 t= 226 R= 4e+05
Depth= 201 States= 8.7e+07 Transitions= 9.75e+07 Memory= 15129.011 t= 238 R= 4e+05
Depth= 201 States= 8.8e+07 Transitions= 9.86e+07 Memory= 15295.710 t= 250 R= 4e+05
Depth= 201 States= 8.9e+07 Transitions= 9.97e+07 Memory= 15462.409 t= 264 R= 3e+05
Depth= 201 States= 9e+07 Transitions= 1.01e+08 Memory= 15629.108 t= 280 R= 3e+05
Depth= 201 States= 9.1e+07 Transitions= 1.02e+08 Memory= 15795.808 t= 297 R= 3e+05
Depth= 201 States= 9.2e+07 Transitions= 1.03e+08 Memory= 15962.605 t= 322 R= 3e+05
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 180 byte, depth reached 201, errors: 0
92736454 states, stored
11160261 states, matched
1.0389672e+08 transitions (= stored+matched)
0 atomic steps
hash conflicts: 20056514 (resolved)
Stats on memory usage (in Megabytes):
18395.598 equivalent memory usage for states (stored*(State-vector + overhead))
15587.671 actual memory usage for states (compression: 84.74%)
state-vector as stored = 148 byte + 28 byte overhead
512.000 memory used for hash table (-w26)
0.534 memory used for DFS stack (-m10000)
14.847 memory lost to fragmentation
16085.358 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_6_8.pml:87, state 77, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_6_8.pml:91, state 87, "-end-"
(2 of 87 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 339 seconds
pan: rate 273502.39 states/second

39
ReversalModel/trace_seq_eq_parallel_2_7_2.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 188 byte, depth reached 221, errors: 0
450520 states, stored
56862 states, matched
507382 transitions (= stored+matched)
0 atomic steps
hash conflicts: 252 (resolved)
Stats on memory usage (in Megabytes):
92.804 equivalent memory usage for states (stored*(State-vector + overhead))
81.912 actual memory usage for states (compression: 88.26%)
state-vector as stored = 163 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
210.272 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_7_2.pml:87, state 71, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_7_2.pml:91, state 81, "-end-"
(2 of 81 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.51 seconds
pan: rate 883372.55 states/second

42
ReversalModel/trace_seq_eq_parallel_2_7_3.txt Normal file
View file

@ -0,0 +1,42 @@
pan: ltl formula seq_eq_parallel
Depth= 221 States= 1e+06 Transitions= 1.13e+06 Memory= 309.784 t= 1.44 R= 7e+05
Depth= 221 States= 2e+06 Transitions= 2.25e+06 Memory= 490.937 t= 2.88 R= 7e+05
Depth= 221 States= 3e+06 Transitions= 3.38e+06 Memory= 671.991 t= 4.34 R= 7e+05
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 188 byte, depth reached 221, errors: 0
3364180 states, stored
425984 states, matched
3790164 transitions (= stored+matched)
0 atomic steps
hash conflicts: 21952 (resolved)
Stats on memory usage (in Megabytes):
693.000 equivalent memory usage for states (stored*(State-vector + overhead))
610.267 actual memory usage for states (compression: 88.06%)
state-vector as stored = 162 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
738.007 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_7_3.pml:87, state 72, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_7_3.pml:91, state 82, "-end-"
(2 of 82 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 4.87 seconds
pan: rate 690796.71 states/second

56
ReversalModel/trace_seq_eq_parallel_2_7_4.txt Normal file
View file

@ -0,0 +1,56 @@
pan: ltl formula seq_eq_parallel
Depth= 221 States= 1e+06 Transitions= 1.13e+06 Memory= 309.784 t= 1.43 R= 7e+05
Depth= 221 States= 2e+06 Transitions= 2.25e+06 Memory= 490.937 t= 2.87 R= 7e+05
Depth= 221 States= 3e+06 Transitions= 3.38e+06 Memory= 672.089 t= 4.33 R= 7e+05
Depth= 221 States= 4e+06 Transitions= 4.51e+06 Memory= 853.241 t= 5.81 R= 7e+05
Depth= 221 States= 5e+06 Transitions= 5.63e+06 Memory= 1034.394 t= 7.31 R= 7e+05
Depth= 221 States= 6e+06 Transitions= 6.76e+06 Memory= 1215.546 t= 8.81 R= 7e+05
Depth= 221 States= 7e+06 Transitions= 7.89e+06 Memory= 1396.698 t= 10.3 R= 7e+05
Depth= 221 States= 8e+06 Transitions= 9.01e+06 Memory= 1577.851 t= 11.8 R= 7e+05
Depth= 221 States= 9e+06 Transitions= 1.01e+07 Memory= 1759.003 t= 13.4 R= 7e+05
Depth= 221 States= 1e+07 Transitions= 1.13e+07 Memory= 1940.155 t= 15 R= 7e+05
Depth= 221 States= 1.1e+07 Transitions= 1.24e+07 Memory= 2121.308 t= 16.5 R= 7e+05
Depth= 221 States= 1.2e+07 Transitions= 1.35e+07 Memory= 2302.460 t= 18.1 R= 7e+05
Depth= 221 States= 1.3e+07 Transitions= 1.46e+07 Memory= 2483.612 t= 19.7 R= 7e+05
Depth= 221 States= 1.4e+07 Transitions= 1.58e+07 Memory= 2664.765 t= 21.3 R= 7e+05
Depth= 221 States= 1.5e+07 Transitions= 1.69e+07 Memory= 2845.917 t= 22.9 R= 7e+05
Depth= 221 States= 1.6e+07 Transitions= 1.8e+07 Memory= 3027.069 t= 24.5 R= 7e+05
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 188 byte, depth reached 221, errors: 0
16015624 states, stored
2031250 states, matched
18046874 transitions (= stored+matched)
0 atomic steps
hash conflicts: 1182338 (resolved)
Stats on memory usage (in Megabytes):
3299.117 equivalent memory usage for states (stored*(State-vector + overhead))
2904.697 actual memory usage for states (compression: 88.04%)
state-vector as stored = 162 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
3.330 memory lost to fragmentation
3029.901 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_7_4.pml:87, state 73, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_7_4.pml:91, state 83, "-end-"
(2 of 83 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 24.5 seconds
pan: rate 652633.41 states/second

98
ReversalModel/trace_seq_eq_parallel_2_7_5.txt Normal file
View file

@ -0,0 +1,98 @@
pan: ltl formula seq_eq_parallel
Depth= 221 States= 1e+06 Transitions= 1.13e+06 Memory= 309.882 t= 1.42 R= 7e+05
Depth= 221 States= 2e+06 Transitions= 2.25e+06 Memory= 491.034 t= 2.87 R= 7e+05
Depth= 221 States= 3e+06 Transitions= 3.38e+06 Memory= 672.284 t= 4.34 R= 7e+05
Depth= 221 States= 4e+06 Transitions= 4.51e+06 Memory= 853.437 t= 5.82 R= 7e+05
Depth= 221 States= 5e+06 Transitions= 5.63e+06 Memory= 1034.687 t= 7.32 R= 7e+05
Depth= 221 States= 6e+06 Transitions= 6.76e+06 Memory= 1215.839 t= 8.83 R= 7e+05
Depth= 221 States= 7e+06 Transitions= 7.89e+06 Memory= 1397.089 t= 10.3 R= 7e+05
Depth= 221 States= 8e+06 Transitions= 9.02e+06 Memory= 1578.241 t= 11.9 R= 7e+05
Depth= 221 States= 9e+06 Transitions= 1.01e+07 Memory= 1759.394 t= 13.4 R= 7e+05
Depth= 221 States= 1e+07 Transitions= 1.13e+07 Memory= 1940.644 t= 15 R= 7e+05
Depth= 221 States= 1.1e+07 Transitions= 1.24e+07 Memory= 2121.796 t= 16.5 R= 7e+05
Depth= 221 States= 1.2e+07 Transitions= 1.35e+07 Memory= 2303.046 t= 18.1 R= 7e+05
Depth= 221 States= 1.3e+07 Transitions= 1.47e+07 Memory= 2484.198 t= 19.7 R= 7e+05
Depth= 221 States= 1.4e+07 Transitions= 1.58e+07 Memory= 2665.448 t= 21.3 R= 7e+05
Depth= 221 States= 1.5e+07 Transitions= 1.69e+07 Memory= 2846.601 t= 22.9 R= 7e+05
Depth= 221 States= 1.6e+07 Transitions= 1.8e+07 Memory= 3027.851 t= 24.6 R= 7e+05
Depth= 221 States= 1.7e+07 Transitions= 1.92e+07 Memory= 3209.003 t= 26.2 R= 6e+05
Depth= 221 States= 1.8e+07 Transitions= 2.03e+07 Memory= 3390.155 t= 27.8 R= 6e+05
Depth= 221 States= 1.9e+07 Transitions= 2.14e+07 Memory= 3571.405 t= 29.4 R= 6e+05
Depth= 221 States= 2e+07 Transitions= 2.25e+07 Memory= 3752.558 t= 31.1 R= 6e+05
Depth= 221 States= 2.1e+07 Transitions= 2.37e+07 Memory= 3933.808 t= 32.8 R= 6e+05
Depth= 221 States= 2.2e+07 Transitions= 2.48e+07 Memory= 4114.960 t= 34.4 R= 6e+05
Depth= 221 States= 2.3e+07 Transitions= 2.59e+07 Memory= 4296.112 t= 36.1 R= 6e+05
Depth= 221 States= 2.4e+07 Transitions= 2.7e+07 Memory= 4477.362 t= 37.8 R= 6e+05
Depth= 221 States= 2.5e+07 Transitions= 2.82e+07 Memory= 4658.515 t= 39.5 R= 6e+05
Depth= 221 States= 2.6e+07 Transitions= 2.93e+07 Memory= 4839.765 t= 41.1 R= 6e+05
Depth= 221 States= 2.7e+07 Transitions= 3.04e+07 Memory= 5020.917 t= 42.9 R= 6e+05
Depth= 221 States= 2.8e+07 Transitions= 3.16e+07 Memory= 5202.167 t= 44.5 R= 6e+05
Depth= 221 States= 2.9e+07 Transitions= 3.27e+07 Memory= 5383.319 t= 46.3 R= 6e+05
Depth= 221 States= 3e+07 Transitions= 3.38e+07 Memory= 5564.569 t= 48 R= 6e+05
Depth= 221 States= 3.1e+07 Transitions= 3.49e+07 Memory= 5745.722 t= 49.7 R= 6e+05
Depth= 221 States= 3.2e+07 Transitions= 3.61e+07 Memory= 5926.874 t= 51.4 R= 6e+05
Depth= 221 States= 3.3e+07 Transitions= 3.72e+07 Memory= 6108.124 t= 53.2 R= 6e+05
Depth= 221 States= 3.4e+07 Transitions= 3.83e+07 Memory= 6289.276 t= 54.9 R= 6e+05
pan: resizing hashtable to -w26.. done
Depth= 221 States= 3.5e+07 Transitions= 3.94e+07 Memory= 6966.511 t= 63.7 R= 5e+05
Depth= 221 States= 3.6e+07 Transitions= 4.06e+07 Memory= 7147.663 t= 65.3 R= 6e+05
Depth= 221 States= 3.7e+07 Transitions= 4.17e+07 Memory= 7328.913 t= 66.9 R= 6e+05
Depth= 221 States= 3.8e+07 Transitions= 4.28e+07 Memory= 7510.065 t= 68.5 R= 6e+05
Depth= 221 States= 3.9e+07 Transitions= 4.4e+07 Memory= 7691.315 t= 70 R= 6e+05
Depth= 221 States= 4e+07 Transitions= 4.51e+07 Memory= 7872.468 t= 71.7 R= 6e+05
Depth= 221 States= 4.1e+07 Transitions= 4.62e+07 Memory= 8053.620 t= 73.3 R= 6e+05
Depth= 221 States= 4.2e+07 Transitions= 4.73e+07 Memory= 8234.870 t= 74.9 R= 6e+05
Depth= 221 States= 4.3e+07 Transitions= 4.85e+07 Memory= 8416.022 t= 76.5 R= 6e+05
Depth= 221 States= 4.4e+07 Transitions= 4.96e+07 Memory= 8597.272 t= 78.1 R= 6e+05
Depth= 221 States= 4.5e+07 Transitions= 5.07e+07 Memory= 8778.425 t= 79.7 R= 6e+05
Depth= 221 States= 4.6e+07 Transitions= 5.18e+07 Memory= 8959.675 t= 81.3 R= 6e+05
Depth= 221 States= 4.7e+07 Transitions= 5.3e+07 Memory= 9140.827 t= 82.9 R= 6e+05
Depth= 221 States= 4.8e+07 Transitions= 5.41e+07 Memory= 9321.980 t= 84.6 R= 6e+05
Depth= 221 States= 4.9e+07 Transitions= 5.52e+07 Memory= 9503.230 t= 86.2 R= 6e+05
Depth= 221 States= 5e+07 Transitions= 5.63e+07 Memory= 9684.382 t= 87.8 R= 6e+05
Depth= 221 States= 5.1e+07 Transitions= 5.75e+07 Memory= 9865.632 t= 89.4 R= 6e+05
Depth= 221 States= 5.2e+07 Transitions= 5.86e+07 Memory= 10046.784 t= 91.1 R= 6e+05
Depth= 221 States= 5.3e+07 Transitions= 5.97e+07 Memory= 10228.034 t= 92.7 R= 6e+05
Depth= 221 States= 5.4e+07 Transitions= 6.09e+07 Memory= 10409.187 t= 94.4 R= 6e+05
Depth= 221 States= 5.5e+07 Transitions= 6.2e+07 Memory= 10590.437 t= 96 R= 6e+05
Depth= 221 States= 5.6e+07 Transitions= 6.31e+07 Memory= 10771.589 t= 98 R= 6e+05
Depth= 221 States= 5.7e+07 Transitions= 6.42e+07 Memory= 10952.741 t= 99.8 R= 6e+05
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 188 byte, depth reached 221, errors: 0
57330892 states, stored
7278336 states, matched
64609228 transitions (= stored+matched)
0 atomic steps
hash conflicts: 10697845 (resolved)
Stats on memory usage (in Megabytes):
11809.800 equivalent memory usage for states (stored*(State-vector + overhead))
10512.871 actual memory usage for states (compression: 89.02%)
state-vector as stored = 164 byte + 28 byte overhead
512.000 memory used for hash table (-w26)
0.534 memory used for DFS stack (-m10000)
12.704 memory lost to fragmentation
11012.702 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_7_5.pml:87, state 74, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_7_5.pml:91, state 84, "-end-"
(2 of 84 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 100 seconds
pan: rate 571366.27 states/second

40
ReversalModel/trace_seq_eq_parallel_2_8_2.txt Normal file
View file

@ -0,0 +1,40 @@
pan: ltl formula seq_eq_parallel
Depth= 241 States= 1e+06 Transitions= 1.13e+06 Memory= 319.452 t= 1.14 R= 9e+05
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 204 byte, depth reached 241, errors: 0
1554955 states, stored
203391 states, matched
1758346 transitions (= stored+matched)
0 atomic steps
hash conflicts: 3480 (resolved)
Stats on memory usage (in Megabytes):
344.038 equivalent memory usage for states (stored*(State-vector + overhead))
297.234 actual memory usage for states (compression: 86.40%)
state-vector as stored = 172 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
425.409 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_8_2.pml:87, state 71, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_8_2.pml:91, state 81, "-end-"
(2 of 81 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 1.78 seconds
pan: rate 873570.22 states/second

55
ReversalModel/trace_seq_eq_parallel_2_8_3.txt Normal file
View file

@ -0,0 +1,55 @@
pan: ltl formula seq_eq_parallel
Depth= 241 States= 1e+06 Transitions= 1.13e+06 Memory= 319.550 t= 1.1 R= 9e+05
Depth= 241 States= 2e+06 Transitions= 2.26e+06 Memory= 510.468 t= 2.2 R= 9e+05
Depth= 241 States= 3e+06 Transitions= 3.39e+06 Memory= 701.288 t= 3.32 R= 9e+05
Depth= 241 States= 4e+06 Transitions= 4.52e+06 Memory= 892.206 t= 4.47 R= 9e+05
Depth= 241 States= 5e+06 Transitions= 5.66e+06 Memory= 1083.026 t= 5.61 R= 9e+05
Depth= 241 States= 6e+06 Transitions= 6.79e+06 Memory= 1273.944 t= 6.76 R= 9e+05
Depth= 241 States= 7e+06 Transitions= 7.92e+06 Memory= 1464.765 t= 7.92 R= 9e+05
Depth= 241 States= 8e+06 Transitions= 9.05e+06 Memory= 1655.683 t= 9.09 R= 9e+05
Depth= 241 States= 9e+06 Transitions= 1.02e+07 Memory= 1846.503 t= 10.3 R= 9e+05
Depth= 241 States= 1e+07 Transitions= 1.13e+07 Memory= 2037.421 t= 11.6 R= 9e+05
Depth= 241 States= 1.1e+07 Transitions= 1.24e+07 Memory= 2228.339 t= 12.8 R= 9e+05
Depth= 241 States= 1.2e+07 Transitions= 1.36e+07 Memory= 2419.159 t= 14.1 R= 9e+05
Depth= 241 States= 1.3e+07 Transitions= 1.47e+07 Memory= 2610.077 t= 15.4 R= 8e+05
Depth= 241 States= 1.4e+07 Transitions= 1.58e+07 Memory= 2800.897 t= 16.9 R= 8e+05
Depth= 241 States= 1.5e+07 Transitions= 1.7e+07 Memory= 2991.815 t= 18.4 R= 8e+05
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 204 byte, depth reached 241, errors: 0
15488340 states, stored
2031616 states, matched
17519956 transitions (= stored+matched)
0 atomic steps
hash conflicts: 1055820 (resolved)
Stats on memory usage (in Megabytes):
3426.833 equivalent memory usage for states (stored*(State-vector + overhead))
2959.177 actual memory usage for states (compression: 86.35%)
state-vector as stored = 172 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
2.732 memory lost to fragmentation
3084.980 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
reversal_seq_eq_parallel_2_8_3.pml:87, state 72, "seq_eq_to_parallel = 0"
reversal_seq_eq_parallel_2_8_3.pml:91, state 82, "-end-"
(2 of 82 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 19.1 seconds
pan: rate 810059.62 states/second

38
ReversalModel/trace_seq_eq_parallel_3_3_2.txt Normal file
View file

@ -0,0 +1,38 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 172 byte, depth reached 167, errors: 0
6343 states, stored
1161 states, matched
7504 transitions (= stored+matched)
0 atomic steps
hash conflicts: 0 (resolved)
Stats on memory usage (in Megabytes):
1.210 equivalent memory usage for states (stored*(State-vector + overhead))
1.161 actual memory usage for states (compression: 95.97%)
state-vector as stored = 164 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
129.608 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_3_2.pml:87, state 71, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_3_2.pml:91, state 81, "-end-"
(2 of 81 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.01 seconds

39
ReversalModel/trace_seq_eq_parallel_3_3_3.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 172 byte, depth reached 167, errors: 0
14996 states, stored
2752 states, matched
17748 transitions (= stored+matched)
0 atomic steps
hash conflicts: 1 (resolved)
Stats on memory usage (in Megabytes):
2.860 equivalent memory usage for states (stored*(State-vector + overhead))
2.529 actual memory usage for states (compression: 88.41%)
state-vector as stored = 149 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
130.976 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_3_3.pml:87, state 72, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_3_3.pml:91, state 82, "-end-"
(2 of 82 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.02 seconds
pan: rate 749800 states/second

39
ReversalModel/trace_seq_eq_parallel_3_3_4.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 172 byte, depth reached 167, errors: 0
29249 states, stored
5375 states, matched
34624 transitions (= stored+matched)
0 atomic steps
hash conflicts: 1 (resolved)
Stats on memory usage (in Megabytes):
5.579 equivalent memory usage for states (stored*(State-vector + overhead))
4.679 actual memory usage for states (compression: 83.87%)
state-vector as stored = 140 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
133.124 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_3_4.pml:87, state 73, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_3_4.pml:91, state 83, "-end-"
(2 of 83 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.1 seconds
pan: rate 292490 states/second

39
ReversalModel/trace_seq_eq_parallel_3_3_5.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 172 byte, depth reached 167, errors: 0
50500 states, stored
9288 states, matched
59788 transitions (= stored+matched)
0 atomic steps
hash conflicts: 7 (resolved)
Stats on memory usage (in Megabytes):
9.632 equivalent memory usage for states (stored*(State-vector + overhead))
8.002 actual memory usage for states (compression: 83.07%)
state-vector as stored = 138 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
136.444 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_3_5.pml:87, state 74, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_3_5.pml:91, state 84, "-end-"
(2 of 84 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.17 seconds
pan: rate 297058.82 states/second

39
ReversalModel/trace_seq_eq_parallel_3_3_6.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 172 byte, depth reached 167, errors: 0
80147 states, stored
14749 states, matched
94896 transitions (= stored+matched)
0 atomic steps
hash conflicts: 14 (resolved)
Stats on memory usage (in Megabytes):
15.287 equivalent memory usage for states (stored*(State-vector + overhead))
12.497 actual memory usage for states (compression: 81.75%)
state-vector as stored = 135 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
140.937 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_3_6.pml:87, state 75, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_3_6.pml:91, state 85, "-end-"
(2 of 85 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.42 seconds
pan: rate 190826.19 states/second

39
ReversalModel/trace_seq_eq_parallel_3_3_7.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 172 byte, depth reached 167, errors: 0
119588 states, stored
22016 states, matched
141604 transitions (= stored+matched)
0 atomic steps
hash conflicts: 30 (resolved)
Stats on memory usage (in Megabytes):
22.810 equivalent memory usage for states (stored*(State-vector + overhead))
18.556 actual memory usage for states (compression: 81.35%)
state-vector as stored = 135 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
146.991 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_3_7.pml:87, state 76, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_3_7.pml:91, state 86, "-end-"
(2 of 86 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.47 seconds
pan: rate 254442.55 states/second

39
ReversalModel/trace_seq_eq_parallel_3_3_8.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 172 byte, depth reached 167, errors: 0
170221 states, stored
31347 states, matched
201568 transitions (= stored+matched)
0 atomic steps
hash conflicts: 68 (resolved)
Stats on memory usage (in Megabytes):
32.467 equivalent memory usage for states (stored*(State-vector + overhead))
26.375 actual memory usage for states (compression: 81.24%)
state-vector as stored = 134 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
154.804 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_3_8.pml:87, state 77, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_3_8.pml:91, state 87, "-end-"
(2 of 87 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.63 seconds
pan: rate 270192.06 states/second

39
ReversalModel/trace_seq_eq_parallel_3_4_2.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 180 byte, depth reached 187, errors: 0
24784 states, stored
4941 states, matched
29725 transitions (= stored+matched)
0 atomic steps
hash conflicts: 2 (resolved)
Stats on memory usage (in Megabytes):
4.916 equivalent memory usage for states (stored*(State-vector + overhead))
4.287 actual memory usage for states (compression: 87.20%)
state-vector as stored = 153 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
132.733 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_4_2.pml:87, state 71, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_4_2.pml:91, state 81, "-end-"
(2 of 81 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.05 seconds
pan: rate 495680 states/second

39
ReversalModel/trace_seq_eq_parallel_3_4_3.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 180 byte, depth reached 187, errors: 0
78164 states, stored
15616 states, matched
93780 transitions (= stored+matched)
0 atomic steps
hash conflicts: 22 (resolved)
Stats on memory usage (in Megabytes):
15.505 equivalent memory usage for states (stored*(State-vector + overhead))
13.178 actual memory usage for states (compression: 84.99%)
state-vector as stored = 149 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
141.620 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_4_3.pml:87, state 72, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_4_3.pml:91, state 82, "-end-"
(2 of 82 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.35 seconds
pan: rate 223325.71 states/second

39
ReversalModel/trace_seq_eq_parallel_3_4_4.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 180 byte, depth reached 187, errors: 0
190624 states, stored
38125 states, matched
228749 transitions (= stored+matched)
0 atomic steps
hash conflicts: 88 (resolved)
Stats on memory usage (in Megabytes):
37.813 equivalent memory usage for states (stored*(State-vector + overhead))
31.742 actual memory usage for states (compression: 83.94%)
state-vector as stored = 147 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
160.175 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_4_4.pml:87, state 73, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_4_4.pml:91, state 83, "-end-"
(2 of 83 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.74 seconds
pan: rate 257600 states/second

39
ReversalModel/trace_seq_eq_parallel_3_4_5.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 180 byte, depth reached 187, errors: 0
395020 states, stored
79056 states, matched
474076 transitions (= stored+matched)
0 atomic steps
hash conflicts: 386 (resolved)
Stats on memory usage (in Megabytes):
78.358 equivalent memory usage for states (stored*(State-vector + overhead))
65.547 actual memory usage for states (compression: 83.65%)
state-vector as stored = 146 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
193.964 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_4_5.pml:87, state 74, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_4_5.pml:91, state 84, "-end-"
(2 of 84 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 1.31 seconds
pan: rate 301541.98 states/second

39
ReversalModel/trace_seq_eq_parallel_3_4_6.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 180 byte, depth reached 187, errors: 0
731504 states, stored
146461 states, matched
877965 transitions (= stored+matched)
0 atomic steps
hash conflicts: 1310 (resolved)
Stats on memory usage (in Megabytes):
145.104 equivalent memory usage for states (stored*(State-vector + overhead))
121.138 actual memory usage for states (compression: 83.48%)
state-vector as stored = 146 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
249.530 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_4_6.pml:87, state 75, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_4_6.pml:91, state 85, "-end-"
(2 of 85 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 3.49 seconds
pan: rate 209600 states/second

40
ReversalModel/trace_seq_eq_parallel_3_4_7.txt Normal file
View file

@ -0,0 +1,40 @@
pan: ltl formula seq_eq_parallel
Depth= 187 States= 1e+06 Transitions= 1.2e+06 Memory= 293.866 t= 4.06 R= 2e+05
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 180 byte, depth reached 187, errors: 0
1247524 states, stored
249856 states, matched
1497380 transitions (= stored+matched)
0 atomic steps
hash conflicts: 4304 (resolved)
Stats on memory usage (in Megabytes):
247.464 equivalent memory usage for states (stored*(State-vector + overhead))
206.424 actual memory usage for states (compression: 83.42%)
state-vector as stored = 146 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
334.784 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_4_7.pml:87, state 76, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_4_7.pml:91, state 86, "-end-"
(2 of 86 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 4.99 seconds
pan: rate 250004.81 states/second

40
ReversalModel/trace_seq_eq_parallel_3_4_8.txt Normal file
View file

@ -0,0 +1,40 @@
pan: ltl formula seq_eq_parallel
Depth= 187 States= 1e+06 Transitions= 1.2e+06 Memory= 293.866 t= 2.57 R= 4e+05
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 180 byte, depth reached 187, errors: 0
1997824 states, stored
400221 states, matched
2398045 transitions (= stored+matched)
0 atomic steps
hash conflicts: 11810 (resolved)
Stats on memory usage (in Megabytes):
396.297 equivalent memory usage for states (stored*(State-vector + overhead))
330.497 actual memory usage for states (compression: 83.40%)
state-vector as stored = 145 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
458.808 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_4_8.pml:87, state 77, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_4_8.pml:91, state 87, "-end-"
(2 of 87 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 5.88 seconds
pan: rate 339765.99 states/second

39
ReversalModel/trace_seq_eq_parallel_3_5_2.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 196 byte, depth reached 207, errors: 0
91609 states, stored
19197 states, matched
110806 transitions (= stored+matched)
0 atomic steps
hash conflicts: 24 (resolved)
Stats on memory usage (in Megabytes):
19.570 equivalent memory usage for states (stored*(State-vector + overhead))
16.801 actual memory usage for states (compression: 85.85%)
state-vector as stored = 164 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
145.233 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_5_2.pml:87, state 71, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_5_2.pml:91, state 81, "-end-"
(2 of 81 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.43 seconds
pan: rate 213044.19 states/second

39
ReversalModel/trace_seq_eq_parallel_3_5_3.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 196 byte, depth reached 207, errors: 0
385364 states, stored
80896 states, matched
466260 transitions (= stored+matched)
0 atomic steps
hash conflicts: 331 (resolved)
Stats on memory usage (in Megabytes):
82.323 equivalent memory usage for states (stored*(State-vector + overhead))
69.981 actual memory usage for states (compression: 85.01%)
state-vector as stored = 162 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
198.358 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_5_3.pml:87, state 72, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_5_3.pml:91, state 82, "-end-"
(2 of 82 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 1.38 seconds
pan: rate 279249.28 states/second

40
ReversalModel/trace_seq_eq_parallel_3_5_4.txt Normal file
View file

@ -0,0 +1,40 @@
pan: ltl formula seq_eq_parallel
Depth= 207 States= 1e+06 Transitions= 1.21e+06 Memory= 309.589 t= 3.19 R= 3e+05
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 196 byte, depth reached 207, errors: 0
1174999 states, stored
246875 states, matched
1421874 transitions (= stored+matched)
0 atomic steps
hash conflicts: 3594 (resolved)
Stats on memory usage (in Megabytes):
251.007 equivalent memory usage for states (stored*(State-vector + overhead))
213.101 actual memory usage for states (compression: 84.90%)
state-vector as stored = 162 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
341.327 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_5_4.pml:87, state 73, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_5_4.pml:91, state 83, "-end-"
(2 of 83 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 3.87 seconds
pan: rate 303617.31 states/second

41
ReversalModel/trace_seq_eq_parallel_3_5_5.txt Normal file
View file

@ -0,0 +1,41 @@
pan: ltl formula seq_eq_parallel
Depth= 207 States= 1e+06 Transitions= 1.21e+06 Memory= 309.687 t= 3.87 R= 3e+05
Depth= 207 States= 2e+06 Transitions= 2.42e+06 Memory= 490.644 t= 7.77 R= 3e+05
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 196 byte, depth reached 207, errors: 0
2922220 states, stored
614304 states, matched
3536524 transitions (= stored+matched)
0 atomic steps
hash conflicts: 27487 (resolved)
Stats on memory usage (in Megabytes):
624.254 equivalent memory usage for states (stored*(State-vector + overhead))
529.642 actual memory usage for states (compression: 84.84%)
state-vector as stored = 162 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
657.538 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_5_5.pml:87, state 74, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_5_5.pml:91, state 84, "-end-"
(2 of 84 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 12.8 seconds
pan: rate 229193.73 states/second

46
ReversalModel/trace_seq_eq_parallel_3_5_6.txt Normal file
View file

@ -0,0 +1,46 @@
pan: ltl formula seq_eq_parallel
Depth= 207 States= 1e+06 Transitions= 1.21e+06 Memory= 309.687 t= 3.85 R= 3e+05
Depth= 207 States= 2e+06 Transitions= 2.42e+06 Memory= 490.644 t= 10 R= 2e+05
Depth= 207 States= 3e+06 Transitions= 3.63e+06 Memory= 671.601 t= 20.5 R= 1e+05
Depth= 207 States= 4e+06 Transitions= 4.84e+06 Memory= 852.558 t= 32.3 R= 1e+05
Depth= 207 States= 5e+06 Transitions= 6.05e+06 Memory= 1033.612 t= 50.6 R= 1e+05
Depth= 207 States= 6e+06 Transitions= 7.26e+06 Memory= 1214.569 t= 68.6 R= 9e+04
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 196 byte, depth reached 207, errors: 0
6313829 states, stored
1327753 states, matched
7641582 transitions (= stored+matched)
0 atomic steps
hash conflicts: 165979 (resolved)
Stats on memory usage (in Megabytes):
1348.779 equivalent memory usage for states (stored*(State-vector + overhead))
1144.039 actual memory usage for states (compression: 84.82%)
state-vector as stored = 162 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
1.266 memory lost to fragmentation
1271.308 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_5_6.pml:87, state 75, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_5_6.pml:91, state 85, "-end-"
(2 of 85 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 74.9 seconds
pan: rate 84330.56 states/second

52
ReversalModel/trace_seq_eq_parallel_3_5_7.txt Normal file
View file

@ -0,0 +1,52 @@
pan: ltl formula seq_eq_parallel
Depth= 207 States= 1e+06 Transitions= 1.21e+06 Memory= 309.687 t= 4.14 R= 2e+05
Depth= 207 States= 2e+06 Transitions= 2.42e+06 Memory= 490.644 t= 9.81 R= 2e+05
Depth= 207 States= 3e+06 Transitions= 3.63e+06 Memory= 671.601 t= 19.6 R= 2e+05
Depth= 207 States= 4e+06 Transitions= 4.84e+06 Memory= 852.655 t= 33.1 R= 1e+05
Depth= 207 States= 5e+06 Transitions= 6.05e+06 Memory= 1033.612 t= 49.8 R= 1e+05
Depth= 207 States= 6e+06 Transitions= 7.26e+06 Memory= 1214.569 t= 71.3 R= 8e+04
Depth= 207 States= 7e+06 Transitions= 8.47e+06 Memory= 1395.624 t= 94.2 R= 7e+04
Depth= 207 States= 8e+06 Transitions= 9.68e+06 Memory= 1576.581 t= 113 R= 7e+04
Depth= 207 States= 9e+06 Transitions= 1.09e+07 Memory= 1757.538 t= 133 R= 7e+04
Depth= 207 States= 1e+07 Transitions= 1.21e+07 Memory= 1938.495 t= 158 R= 6e+04
Depth= 207 States= 1.1e+07 Transitions= 1.33e+07 Memory= 2119.550 t= 187 R= 6e+04
Depth= 207 States= 1.2e+07 Transitions= 1.45e+07 Memory= 2300.507 t= 217 R= 6e+04
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 196 byte, depth reached 207, errors: 0
12306724 states, stored
2588672 states, matched
14895396 transitions (= stored+matched)
0 atomic steps
hash conflicts: 857890 (resolved)
Stats on memory usage (in Megabytes):
2629.000 equivalent memory usage for states (stored*(State-vector + overhead))
2229.897 actual memory usage for states (compression: 84.82%)
state-vector as stored = 162 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
2.359 memory lost to fragmentation
2356.073 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_5_7.pml:87, state 76, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_3_5_7.pml:91, state 86, "-end-"
(2 of 86 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 226 seconds
pan: rate 54495.523 states/second

39
ReversalModel/trace_seq_eq_parallel_4_3_2.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 196 byte, depth reached 193, errors: 0
9205 states, stored
2889 states, matched
12094 transitions (= stored+matched)
0 atomic steps
hash conflicts: 0 (resolved)
Stats on memory usage (in Megabytes):
1.966 equivalent memory usage for states (stored*(State-vector + overhead))
1.845 actual memory usage for states (compression: 93.82%)
state-vector as stored = 182 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
130.292 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_3_2.pml:87, state 71, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_3_2.pml:91, state 81, "-end-"
(2 of 81 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.02 seconds
pan: rate 460250 states/second

39
ReversalModel/trace_seq_eq_parallel_4_3_3.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 196 byte, depth reached 193, errors: 0
21780 states, stored
6848 states, matched
28628 transitions (= stored+matched)
0 atomic steps
hash conflicts: 4 (resolved)
Stats on memory usage (in Megabytes):
4.653 equivalent memory usage for states (stored*(State-vector + overhead))
3.897 actual memory usage for states (compression: 83.76%)
state-vector as stored = 160 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
132.343 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_3_3.pml:87, state 72, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_3_3.pml:91, state 82, "-end-"
(2 of 82 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.05 seconds
pan: rate 435600 states/second

39
ReversalModel/trace_seq_eq_parallel_4_3_4.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 196 byte, depth reached 193, errors: 0
42499 states, stored
13375 states, matched
55874 transitions (= stored+matched)
0 atomic steps
hash conflicts: 7 (resolved)
Stats on memory usage (in Megabytes):
9.079 equivalent memory usage for states (stored*(State-vector + overhead))
7.513 actual memory usage for states (compression: 82.76%)
state-vector as stored = 157 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
135.956 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_3_4.pml:87, state 73, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_3_4.pml:91, state 83, "-end-"
(2 of 83 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.07 seconds
pan: rate 607128.57 states/second

39
ReversalModel/trace_seq_eq_parallel_4_3_5.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 196 byte, depth reached 193, errors: 0
73396 states, stored
23112 states, matched
96508 transitions (= stored+matched)
0 atomic steps
hash conflicts: 19 (resolved)
Stats on memory usage (in Megabytes):
15.679 equivalent memory usage for states (stored*(State-vector + overhead))
12.693 actual memory usage for states (compression: 80.95%)
state-vector as stored = 153 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
141.132 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_3_5.pml:87, state 74, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_3_5.pml:91, state 84, "-end-"
(2 of 84 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.12 seconds
pan: rate 611633.33 states/second

39
ReversalModel/trace_seq_eq_parallel_4_3_6.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 196 byte, depth reached 193, errors: 0
116505 states, stored
36701 states, matched
153206 transitions (= stored+matched)
0 atomic steps
hash conflicts: 43 (resolved)
Stats on memory usage (in Megabytes):
24.888 equivalent memory usage for states (stored*(State-vector + overhead))
20.023 actual memory usage for states (compression: 80.45%)
state-vector as stored = 152 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
148.456 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_3_6.pml:87, state 75, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_3_6.pml:91, state 85, "-end-"
(2 of 85 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.19 seconds
pan: rate 613184.21 states/second

39
ReversalModel/trace_seq_eq_parallel_4_3_7.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 196 byte, depth reached 193, errors: 0
173860 states, stored
54784 states, matched
228644 transitions (= stored+matched)
0 atomic steps
hash conflicts: 126 (resolved)
Stats on memory usage (in Megabytes):
37.141 equivalent memory usage for states (stored*(State-vector + overhead))
29.797 actual memory usage for states (compression: 80.23%)
state-vector as stored = 152 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
158.222 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_3_7.pml:87, state 76, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_3_7.pml:91, state 86, "-end-"
(2 of 86 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.33 seconds
pan: rate 526848.48 states/second

39
ReversalModel/trace_seq_eq_parallel_4_3_8.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 196 byte, depth reached 193, errors: 0
247495 states, stored
78003 states, matched
325498 transitions (= stored+matched)
0 atomic steps
hash conflicts: 244 (resolved)
Stats on memory usage (in Megabytes):
52.871 equivalent memory usage for states (stored*(State-vector + overhead))
42.404 actual memory usage for states (compression: 80.20%)
state-vector as stored = 152 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
170.819 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_3_8.pml:87, state 77, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_3_8.pml:91, state 87, "-end-"
(2 of 87 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.38 seconds
pan: rate 651302.63 states/second

39
ReversalModel/trace_seq_eq_parallel_4_4_2.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 204 byte, depth reached 213, errors: 0
60505 states, stored
16605 states, matched
77110 transitions (= stored+matched)
0 atomic steps
hash conflicts: 9 (resolved)
Stats on memory usage (in Megabytes):
13.387 equivalent memory usage for states (stored*(State-vector + overhead))
11.521 actual memory usage for states (compression: 86.06%)
state-vector as stored = 172 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
139.960 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_4_2.pml:87, state 71, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_4_2.pml:91, state 81, "-end-"
(2 of 81 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.1 seconds
pan: rate 605050 states/second

39
ReversalModel/trace_seq_eq_parallel_4_4_3.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 204 byte, depth reached 213, errors: 0
191060 states, stored
52480 states, matched
243540 transitions (= stored+matched)
0 atomic steps
hash conflicts: 134 (resolved)
Stats on memory usage (in Megabytes):
42.272 equivalent memory usage for states (stored*(State-vector + overhead))
35.855 actual memory usage for states (compression: 84.82%)
state-vector as stored = 169 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
164.276 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_4_3.pml:87, state 72, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_4_3.pml:91, state 82, "-end-"
(2 of 82 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.34 seconds
pan: rate 561941.18 states/second

39
ReversalModel/trace_seq_eq_parallel_4_4_4.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 204 byte, depth reached 213, errors: 0
466249 states, stored
128125 states, matched
594374 transitions (= stored+matched)
0 atomic steps
hash conflicts: 856 (resolved)
Stats on memory usage (in Megabytes):
103.159 equivalent memory usage for states (stored*(State-vector + overhead))
87.260 actual memory usage for states (compression: 84.59%)
state-vector as stored = 168 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
215.644 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_4_4.pml:87, state 73, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_4_4.pml:91, state 83, "-end-"
(2 of 83 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.9 seconds
pan: rate 518054.44 states/second

39
ReversalModel/trace_seq_eq_parallel_4_4_5.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 204 byte, depth reached 213, errors: 0
966556 states, stored
265680 states, matched
1232236 transitions (= stored+matched)
0 atomic steps
hash conflicts: 3685 (resolved)
Stats on memory usage (in Megabytes):
213.853 equivalent memory usage for states (stored*(State-vector + overhead))
180.597 actual memory usage for states (compression: 84.45%)
state-vector as stored = 168 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
308.905 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_4_5.pml:87, state 74, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_4_5.pml:91, state 84, "-end-"
(2 of 84 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 2.22 seconds
pan: rate 435385.59 states/second

40
ReversalModel/trace_seq_eq_parallel_4_4_6.txt Normal file
View file

@ -0,0 +1,40 @@
pan: ltl formula seq_eq_parallel
Depth= 213 States= 1e+06 Transitions= 1.27e+06 Memory= 315.155 t= 2.09 R= 5e+05
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 204 byte, depth reached 213, errors: 0
1790345 states, stored
492205 states, matched
2282550 transitions (= stored+matched)
0 atomic steps
hash conflicts: 14027 (resolved)
Stats on memory usage (in Megabytes):
396.118 equivalent memory usage for states (stored*(State-vector + overhead))
334.431 actual memory usage for states (compression: 84.43%)
state-vector as stored = 168 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
462.616 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_4_6.pml:87, state 75, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_4_6.pml:91, state 85, "-end-"
(2 of 85 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 3.64 seconds
pan: rate 491853.02 states/second

42
ReversalModel/trace_seq_eq_parallel_4_4_7.txt Normal file
View file

@ -0,0 +1,42 @@
pan: ltl formula seq_eq_parallel
Depth= 213 States= 1e+06 Transitions= 1.27e+06 Memory= 315.155 t= 1.86 R= 5e+05
Depth= 213 States= 2e+06 Transitions= 2.55e+06 Memory= 501.679 t= 3.74 R= 5e+05
Depth= 213 States= 3e+06 Transitions= 3.82e+06 Memory= 688.202 t= 5.9 R= 5e+05
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 204 byte, depth reached 213, errors: 0
3053860 states, stored
839680 states, matched
3893540 transitions (= stored+matched)
0 atomic steps
hash conflicts: 44932 (resolved)
Stats on memory usage (in Megabytes):
675.674 equivalent memory usage for states (stored*(State-vector + overhead))
570.246 actual memory usage for states (compression: 84.40%)
state-vector as stored = 168 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
698.261 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_4_7.pml:87, state 76, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_4_7.pml:91, state 86, "-end-"
(2 of 86 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 6 seconds
pan: rate 508976.67 states/second

43
ReversalModel/trace_seq_eq_parallel_4_4_8.txt Normal file
View file

@ -0,0 +1,43 @@
pan: ltl formula seq_eq_parallel
Depth= 213 States= 1e+06 Transitions= 1.27e+06 Memory= 315.155 t= 1.87 R= 5e+05
Depth= 213 States= 2e+06 Transitions= 2.55e+06 Memory= 501.679 t= 3.81 R= 5e+05
Depth= 213 States= 3e+06 Transitions= 3.82e+06 Memory= 688.202 t= 5.88 R= 5e+05
Depth= 213 States= 4e+06 Transitions= 5.1e+06 Memory= 874.726 t= 7.99 R= 5e+05
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 204 byte, depth reached 213, errors: 0
4891225 states, stored
1345005 states, matched
6236230 transitions (= stored+matched)
0 atomic steps
hash conflicts: 130137 (resolved)
Stats on memory usage (in Megabytes):
1082.195 equivalent memory usage for states (stored*(State-vector + overhead))
913.265 actual memory usage for states (compression: 84.39%)
state-vector as stored = 168 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
1041.034 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_4_8.pml:87, state 77, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_4_8.pml:91, state 87, "-end-"
(2 of 87 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 10 seconds
pan: rate 487173.8 states/second

39
ReversalModel/trace_seq_eq_parallel_4_5_2.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 220 byte, depth reached 233, errors: 0
242512 states, stored
69498 states, matched
312010 transitions (= stored+matched)
0 atomic steps
hash conflicts: 235 (resolved)
Stats on memory usage (in Megabytes):
57.357 equivalent memory usage for states (stored*(State-vector + overhead))
48.364 actual memory usage for states (compression: 84.32%)
state-vector as stored = 181 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
176.776 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_5_2.pml:87, state 71, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_5_2.pml:91, state 81, "-end-"
(2 of 81 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.63 seconds
pan: rate 384939.68 states/second

40
ReversalModel/trace_seq_eq_parallel_4_5_3.txt Normal file
View file

@ -0,0 +1,40 @@
pan: ltl formula seq_eq_parallel
Depth= 233 States= 1e+06 Transitions= 1.29e+06 Memory= 327.069 t= 2.05 R= 5e+05
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 220 byte, depth reached 233, errors: 0
1021268 states, stored
292864 states, matched
1314132 transitions (= stored+matched)
0 atomic steps
hash conflicts: 4180 (resolved)
Stats on memory usage (in Megabytes):
241.541 equivalent memory usage for states (stored*(State-vector + overhead))
202.987 actual memory usage for states (compression: 84.04%)
state-vector as stored = 180 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
331.269 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_5_3.pml:87, state 72, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_5_3.pml:91, state 82, "-end-"
(2 of 82 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 2.09 seconds
pan: rate 488644.98 states/second

42
ReversalModel/trace_seq_eq_parallel_4_5_4.txt Normal file
View file

@ -0,0 +1,42 @@
pan: ltl formula seq_eq_parallel
Depth= 233 States= 1e+06 Transitions= 1.29e+06 Memory= 327.069 t= 1.83 R= 5e+05
Depth= 233 States= 2e+06 Transitions= 2.57e+06 Memory= 525.409 t= 3.88 R= 5e+05
Depth= 233 States= 3e+06 Transitions= 3.86e+06 Memory= 723.749 t= 6.17 R= 5e+05
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 220 byte, depth reached 233, errors: 0
3115624 states, stored
893750 states, matched
4009374 transitions (= stored+matched)
0 atomic steps
hash conflicts: 47006 (resolved)
Stats on memory usage (in Megabytes):
736.880 equivalent memory usage for states (stored*(State-vector + overhead))
618.743 actual memory usage for states (compression: 83.97%)
state-vector as stored = 180 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
746.698 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_5_4.pml:87, state 73, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_5_4.pml:91, state 83, "-end-"
(2 of 83 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 6.47 seconds
pan: rate 481549.3 states/second

47
ReversalModel/trace_seq_eq_parallel_4_5_5.txt Normal file
View file

@ -0,0 +1,47 @@
pan: ltl formula seq_eq_parallel
Depth= 233 States= 1e+06 Transitions= 1.29e+06 Memory= 327.069 t= 1.85 R= 5e+05
Depth= 233 States= 2e+06 Transitions= 2.57e+06 Memory= 525.409 t= 3.9 R= 5e+05
Depth= 233 States= 3e+06 Transitions= 3.86e+06 Memory= 723.847 t= 5.98 R= 5e+05
Depth= 233 States= 4e+06 Transitions= 5.15e+06 Memory= 922.187 t= 8.09 R= 5e+05
Depth= 233 States= 5e+06 Transitions= 6.43e+06 Memory= 1120.624 t= 10.9 R= 5e+05
Depth= 233 States= 6e+06 Transitions= 7.72e+06 Memory= 1318.964 t= 14.1 R= 4e+05
Depth= 233 States= 7e+06 Transitions= 9.01e+06 Memory= 1517.401 t= 18.3 R= 4e+05
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 220 byte, depth reached 233, errors: 0
7751116 states, stored
2223936 states, matched
9975052 transitions (= stored+matched)
0 atomic steps
hash conflicts: 372235 (resolved)
Stats on memory usage (in Megabytes):
1833.226 equivalent memory usage for states (stored*(State-vector + overhead))
1539.317 actual memory usage for states (compression: 83.97%)
state-vector as stored = 180 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
1.426 memory lost to fragmentation
1666.425 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_5_5.pml:87, state 74, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_5_5.pml:91, state 84, "-end-"
(2 of 84 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 21.8 seconds
pan: rate 356209.38 states/second

56
ReversalModel/trace_seq_eq_parallel_4_5_6.txt Normal file
View file

@ -0,0 +1,56 @@
pan: ltl formula seq_eq_parallel
Depth= 233 States= 1e+06 Transitions= 1.29e+06 Memory= 327.069 t= 1.62 R= 6e+05
Depth= 233 States= 2e+06 Transitions= 2.57e+06 Memory= 525.409 t= 3.89 R= 5e+05
Depth= 233 States= 3e+06 Transitions= 3.86e+06 Memory= 723.847 t= 6.35 R= 5e+05
Depth= 233 States= 4e+06 Transitions= 5.15e+06 Memory= 922.187 t= 8.88 R= 5e+05
Depth= 233 States= 5e+06 Transitions= 6.43e+06 Memory= 1120.624 t= 11.7 R= 4e+05
Depth= 233 States= 6e+06 Transitions= 7.72e+06 Memory= 1318.964 t= 14.6 R= 4e+05
Depth= 233 States= 7e+06 Transitions= 9.01e+06 Memory= 1517.401 t= 18.1 R= 4e+05
Depth= 233 States= 8e+06 Transitions= 1.03e+07 Memory= 1715.741 t= 22.6 R= 4e+05
Depth= 233 States= 9e+06 Transitions= 1.16e+07 Memory= 1914.179 t= 31.4 R= 3e+05
Depth= 233 States= 1e+07 Transitions= 1.29e+07 Memory= 2112.519 t= 36.5 R= 3e+05
Depth= 233 States= 1.1e+07 Transitions= 1.42e+07 Memory= 2310.956 t= 42.7 R= 3e+05
Depth= 233 States= 1.2e+07 Transitions= 1.54e+07 Memory= 2509.296 t= 53.4 R= 2e+05
Depth= 233 States= 1.3e+07 Transitions= 1.67e+07 Memory= 2707.733 t= 64.5 R= 2e+05
Depth= 233 States= 1.4e+07 Transitions= 1.8e+07 Memory= 2906.073 t= 76.8 R= 2e+05
Depth= 233 States= 1.5e+07 Transitions= 1.93e+07 Memory= 3104.511 t= 93.7 R= 2e+05
Depth= 233 States= 1.6e+07 Transitions= 2.06e+07 Memory= 3302.851 t= 116 R= 1e+05
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 220 byte, depth reached 233, errors: 0
16750976 states, stored
4806802 states, matched
21557778 transitions (= stored+matched)
0 atomic steps
hash conflicts: 2356978 (resolved)
Stats on memory usage (in Megabytes):
3961.794 equivalent memory usage for states (stored*(State-vector + overhead))
3326.181 actual memory usage for states (compression: 83.96%)
state-vector as stored = 180 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
2.842 memory lost to fragmentation
3451.874 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_5_6.pml:87, state 75, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_4_5_6.pml:91, state 85, "-end-"
(2 of 85 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 139 seconds
pan: rate 120692.96 states/second

39
ReversalModel/trace_seq_eq_parallel_5_3_2.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 220 byte, depth reached 219, errors: 0
17710 states, stored
7857 states, matched
25567 transitions (= stored+matched)
0 atomic steps
hash conflicts: 7 (resolved)
Stats on memory usage (in Megabytes):
4.189 equivalent memory usage for states (stored*(State-vector + overhead))
3.702 actual memory usage for states (compression: 88.39%)
state-vector as stored = 191 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
132.147 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_3_2.pml:87, state 71, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_3_2.pml:91, state 81, "-end-"
(2 of 81 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.04 seconds
pan: rate 442750 states/second

39
ReversalModel/trace_seq_eq_parallel_5_3_3.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 220 byte, depth reached 219, errors: 0
41940 states, stored
18624 states, matched
60564 transitions (= stored+matched)
0 atomic steps
hash conflicts: 13 (resolved)
Stats on memory usage (in Megabytes):
9.919 equivalent memory usage for states (stored*(State-vector + overhead))
8.393 actual memory usage for states (compression: 84.61%)
state-vector as stored = 182 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
136.835 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_3_3.pml:87, state 72, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_3_3.pml:91, state 82, "-end-"
(2 of 82 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.09 seconds
pan: rate 466000 states/second

39
ReversalModel/trace_seq_eq_parallel_5_3_4.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 220 byte, depth reached 219, errors: 0
81874 states, stored
36375 states, matched
118249 transitions (= stored+matched)
0 atomic steps
hash conflicts: 45 (resolved)
Stats on memory usage (in Megabytes):
19.364 equivalent memory usage for states (stored*(State-vector + overhead))
16.113 actual memory usage for states (compression: 83.21%)
state-vector as stored = 178 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
144.550 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_3_4.pml:87, state 73, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_3_4.pml:91, state 83, "-end-"
(2 of 83 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.17 seconds
pan: rate 481611.76 states/second

39
ReversalModel/trace_seq_eq_parallel_5_3_5.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 220 byte, depth reached 219, errors: 0
141436 states, stored
62856 states, matched
204292 transitions (= stored+matched)
0 atomic steps
hash conflicts: 93 (resolved)
Stats on memory usage (in Megabytes):
33.451 equivalent memory usage for states (stored*(State-vector + overhead))
27.645 actual memory usage for states (compression: 82.64%)
state-vector as stored = 177 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
156.073 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_3_5.pml:87, state 74, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_3_5.pml:91, state 84, "-end-"
(2 of 84 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.3 seconds
pan: rate 471453.33 states/second

39
ReversalModel/trace_seq_eq_parallel_5_3_6.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 220 byte, depth reached 219, errors: 0
224550 states, stored
99813 states, matched
324363 transitions (= stored+matched)
0 atomic steps
hash conflicts: 332 (resolved)
Stats on memory usage (in Megabytes):
53.109 equivalent memory usage for states (stored*(State-vector + overhead))
43.675 actual memory usage for states (compression: 82.24%)
state-vector as stored = 176 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
172.089 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_3_6.pml:87, state 75, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_3_6.pml:91, state 85, "-end-"
(2 of 85 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.4 seconds
pan: rate 561375 states/second

39
ReversalModel/trace_seq_eq_parallel_5_3_7.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 220 byte, depth reached 219, errors: 0
335140 states, stored
148992 states, matched
484132 transitions (= stored+matched)
0 atomic steps
hash conflicts: 619 (resolved)
Stats on memory usage (in Megabytes):
79.264 equivalent memory usage for states (stored*(State-vector + overhead))
65.079 actual memory usage for states (compression: 82.10%)
state-vector as stored = 176 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
193.476 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_3_7.pml:87, state 76, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_3_7.pml:91, state 86, "-end-"
(2 of 86 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.58 seconds
pan: rate 577827.59 states/second

39
ReversalModel/trace_seq_eq_parallel_5_3_8.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 220 byte, depth reached 219, errors: 0
477130 states, stored
212139 states, matched
689269 transitions (= stored+matched)
0 atomic steps
hash conflicts: 1395 (resolved)
Stats on memory usage (in Megabytes):
112.847 equivalent memory usage for states (stored*(State-vector + overhead))
92.546 actual memory usage for states (compression: 82.01%)
state-vector as stored = 175 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
220.917 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_3_8.pml:87, state 77, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_3_8.pml:91, state 87, "-end-"
(2 of 87 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.97 seconds
pan: rate 491886.6 states/second

39
ReversalModel/trace_seq_eq_parallel_5_4_2.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 228 byte, depth reached 239, errors: 0
63340 states, stored
28755 states, matched
92095 transitions (= stored+matched)
0 atomic steps
hash conflicts: 38 (resolved)
Stats on memory usage (in Megabytes):
15.464 equivalent memory usage for states (stored*(State-vector + overhead))
13.083 actual memory usage for states (compression: 84.61%)
state-vector as stored = 189 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
141.522 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_4_2.pml:87, state 71, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_4_2.pml:91, state 81, "-end-"
(2 of 81 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.13 seconds
pan: rate 487230.77 states/second

39
ReversalModel/trace_seq_eq_parallel_5_4_3.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 228 byte, depth reached 239, errors: 0
200020 states, stored
90880 states, matched
290900 transitions (= stored+matched)
0 atomic steps
hash conflicts: 258 (resolved)
Stats on memory usage (in Megabytes):
48.833 equivalent memory usage for states (stored*(State-vector + overhead))
40.936 actual memory usage for states (compression: 83.83%)
state-vector as stored = 187 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
169.355 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_4_3.pml:87, state 72, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_4_3.pml:91, state 82, "-end-"
(2 of 82 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.45 seconds
pan: rate 444488.89 states/second

39
ReversalModel/trace_seq_eq_parallel_5_4_4.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 228 byte, depth reached 239, errors: 0
488124 states, stored
221875 states, matched
709999 transitions (= stored+matched)
0 atomic steps
hash conflicts: 1355 (resolved)
Stats on memory usage (in Megabytes):
119.171 equivalent memory usage for states (stored*(State-vector + overhead))
99.669 actual memory usage for states (compression: 83.64%)
state-vector as stored = 186 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
228.046 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_4_4.pml:87, state 73, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_4_4.pml:91, state 83, "-end-"
(2 of 83 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.97 seconds
pan: rate 503220.62 states/second

40
ReversalModel/trace_seq_eq_parallel_5_4_5.txt Normal file
View file

@ -0,0 +1,40 @@
pan: ltl formula seq_eq_parallel
Depth= 239 States= 1e+06 Transitions= 1.45e+06 Memory= 332.147 t= 2.23 R= 4e+05
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 228 byte, depth reached 239, errors: 0
1011916 states, stored
460080 states, matched
1471996 transitions (= stored+matched)
0 atomic steps
hash conflicts: 6336 (resolved)
Stats on memory usage (in Megabytes):
247.050 equivalent memory usage for states (stored*(State-vector + overhead))
206.288 actual memory usage for states (compression: 83.50%)
state-vector as stored = 186 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
334.589 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_4_5.pml:87, state 74, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_4_5.pml:91, state 84, "-end-"
(2 of 84 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 2.26 seconds
pan: rate 447750.44 states/second

40
ReversalModel/trace_seq_eq_parallel_5_4_6.txt Normal file
View file

@ -0,0 +1,40 @@
pan: ltl formula seq_eq_parallel
Depth= 239 States= 1e+06 Transitions= 1.45e+06 Memory= 332.245 t= 2.19 R= 5e+05
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 228 byte, depth reached 239, errors: 0
1874380 states, stored
852355 states, matched
2726735 transitions (= stored+matched)
0 atomic steps
hash conflicts: 22212 (resolved)
Stats on memory usage (in Megabytes):
457.612 equivalent memory usage for states (stored*(State-vector + overhead))
382.007 actual memory usage for states (compression: 83.48%)
state-vector as stored = 186 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
510.175 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_4_6.pml:87, state 75, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_4_6.pml:91, state 85, "-end-"
(2 of 85 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 4.36 seconds
pan: rate 429903.67 states/second

42
ReversalModel/trace_seq_eq_parallel_5_4_7.txt Normal file
View file

@ -0,0 +1,42 @@
pan: ltl formula seq_eq_parallel
Depth= 239 States= 1e+06 Transitions= 1.45e+06 Memory= 332.245 t= 2.27 R= 4e+05
Depth= 239 States= 2e+06 Transitions= 2.91e+06 Memory= 535.761 t= 5.99 R= 3e+05
Depth= 239 States= 3e+06 Transitions= 4.36e+06 Memory= 739.276 t= 10.6 R= 3e+05
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 228 byte, depth reached 239, errors: 0
3197220 states, stored
1454080 states, matched
4651300 transitions (= stored+matched)
0 atomic steps
hash conflicts: 70285 (resolved)
Stats on memory usage (in Megabytes):
780.571 equivalent memory usage for states (stored*(State-vector + overhead))
651.428 actual memory usage for states (compression: 83.46%)
state-vector as stored = 186 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
779.413 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_4_7.pml:87, state 76, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_4_7.pml:91, state 86, "-end-"
(2 of 86 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 11.5 seconds
pan: rate 277536.46 states/second

44
ReversalModel/trace_seq_eq_parallel_5_4_8.txt Normal file
View file

@ -0,0 +1,44 @@
pan: ltl formula seq_eq_parallel
Depth= 239 States= 1e+06 Transitions= 1.45e+06 Memory= 332.245 t= 2.05 R= 5e+05
Depth= 239 States= 2e+06 Transitions= 2.91e+06 Memory= 535.761 t= 4.34 R= 5e+05
Depth= 239 States= 3e+06 Transitions= 4.36e+06 Memory= 739.276 t= 7.02 R= 4e+05
Depth= 239 States= 4e+06 Transitions= 5.82e+06 Memory= 942.792 t= 11.2 R= 4e+05
Depth= 239 States= 5e+06 Transitions= 7.27e+06 Memory= 1146.308 t= 17 R= 3e+05
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 228 byte, depth reached 239, errors: 0
5120860 states, stored
2329155 states, matched
7450015 transitions (= stored+matched)
0 atomic steps
hash conflicts: 195848 (resolved)
Stats on memory usage (in Megabytes):
1250.210 equivalent memory usage for states (stored*(State-vector + overhead))
1043.210 actual memory usage for states (compression: 83.44%)
state-vector as stored = 186 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
1170.917 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_4_8.pml:87, state 77, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_4_8.pml:91, state 87, "-end-"
(2 of 87 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 17.8 seconds
pan: rate 288012.37 states/second

39
ReversalModel/trace_seq_eq_parallel_5_5_2.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 244 byte, depth reached 259, errors: 0
607984 states, stored
207279 states, matched
815263 transitions (= stored+matched)
0 atomic steps
hash conflicts: 1917 (resolved)
Stats on memory usage (in Megabytes):
157.711 equivalent memory usage for states (stored*(State-vector + overhead))
133.563 actual memory usage for states (compression: 84.69%)
state-vector as stored = 202 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
261.835 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_5_2.pml:87, state 71, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_5_2.pml:91, state 81, "-end-"
(2 of 81 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 2.8 seconds
pan: rate 217137.14 states/second

41
ReversalModel/trace_seq_eq_parallel_5_5_3.txt Normal file
View file

@ -0,0 +1,41 @@
pan: ltl formula seq_eq_parallel
Depth= 259 States= 1e+06 Transitions= 1.34e+06 Memory= 347.675 t= 3.44 R= 3e+05
Depth= 259 States= 2e+06 Transitions= 2.68e+06 Memory= 566.718 t= 7.92 R= 3e+05
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 244 byte, depth reached 259, errors: 0
2561364 states, stored
873472 states, matched
3434836 transitions (= stored+matched)
0 atomic steps
hash conflicts: 38601 (resolved)
Stats on memory usage (in Megabytes):
664.416 equivalent memory usage for states (stored*(State-vector + overhead))
561.969 actual memory usage for states (compression: 84.58%)
state-vector as stored = 202 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
689.667 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_5_3.pml:87, state 72, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_5_3.pml:91, state 82, "-end-"
(2 of 82 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 10.6 seconds
pan: rate 242783.32 states/second

47
ReversalModel/trace_seq_eq_parallel_5_5_4.txt Normal file
View file

@ -0,0 +1,47 @@
pan: ltl formula seq_eq_parallel
Depth= 259 States= 1e+06 Transitions= 1.34e+06 Memory= 347.675 t= 3.95 R= 3e+05
Depth= 259 States= 2e+06 Transitions= 2.68e+06 Memory= 566.718 t= 8.29 R= 2e+05
Depth= 259 States= 3e+06 Transitions= 4.02e+06 Memory= 785.663 t= 13.9 R= 2e+05
Depth= 259 States= 4e+06 Transitions= 5.36e+06 Memory= 1004.706 t= 19.5 R= 2e+05
Depth= 259 States= 5e+06 Transitions= 6.71e+06 Memory= 1223.749 t= 28.5 R= 2e+05
Depth= 259 States= 6e+06 Transitions= 8.05e+06 Memory= 1442.694 t= 38.6 R= 2e+05
Depth= 259 States= 7e+06 Transitions= 9.39e+06 Memory= 1661.737 t= 51.2 R= 1e+05
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 244 byte, depth reached 259, errors: 0
7815624 states, stored
2665625 states, matched
10481249 transitions (= stored+matched)
0 atomic steps
hash conflicts: 459569 (resolved)
Stats on memory usage (in Megabytes):
2027.368 equivalent memory usage for states (stored*(State-vector + overhead))
1714.168 actual memory usage for states (compression: 84.55%)
state-vector as stored = 202 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
2.353 memory lost to fragmentation
1840.351 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_5_4.pml:87, state 73, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_5_5_4.pml:91, state 83, "-end-"
(2 of 83 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 67 seconds
pan: rate 116685.94 states/second

39
ReversalModel/trace_seq_eq_parallel_6_3_2.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 244 byte, depth reached 245, errors: 0
34450 states, stored
19953 states, matched
54403 transitions (= stored+matched)
0 atomic steps
hash conflicts: 17 (resolved)
Stats on memory usage (in Megabytes):
8.936 equivalent memory usage for states (stored*(State-vector + overhead))
7.514 actual memory usage for states (compression: 84.09%)
state-vector as stored = 201 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
135.956 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_6_3_2.pml:87, state 71, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_6_3_2.pml:91, state 81, "-end-"
(2 of 81 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.11 seconds
pan: rate 313181.82 states/second

39
ReversalModel/trace_seq_eq_parallel_6_3_3.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 244 byte, depth reached 245, errors: 0
81620 states, stored
47296 states, matched
128916 transitions (= stored+matched)
0 atomic steps
hash conflicts: 67 (resolved)
Stats on memory usage (in Megabytes):
21.172 equivalent memory usage for states (stored*(State-vector + overhead))
17.484 actual memory usage for states (compression: 82.58%)
state-vector as stored = 197 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
145.917 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_6_3_3.pml:87, state 72, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_6_3_3.pml:91, state 82, "-end-"
(2 of 82 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.24 seconds
pan: rate 340083.33 states/second

39
ReversalModel/trace_seq_eq_parallel_6_3_4.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 244 byte, depth reached 245, errors: 0
159374 states, stored
92375 states, matched
251749 transitions (= stored+matched)
0 atomic steps
hash conflicts: 190 (resolved)
Stats on memory usage (in Megabytes):
41.342 equivalent memory usage for states (stored*(State-vector + overhead))
33.906 actual memory usage for states (compression: 82.01%)
state-vector as stored = 195 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
162.323 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_6_3_4.pml:87, state 73, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_6_3_4.pml:91, state 83, "-end-"
(2 of 83 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 0.48 seconds
pan: rate 332029.17 states/second

39
ReversalModel/trace_seq_eq_parallel_6_3_5.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 244 byte, depth reached 245, errors: 0
275356 states, stored
159624 states, matched
434980 transitions (= stored+matched)
0 atomic steps
hash conflicts: 593 (resolved)
Stats on memory usage (in Megabytes):
71.427 equivalent memory usage for states (stored*(State-vector + overhead))
58.440 actual memory usage for states (compression: 81.82%)
state-vector as stored = 195 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
186.835 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_6_3_5.pml:87, state 74, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_6_3_5.pml:91, state 84, "-end-"
(2 of 84 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 1.13 seconds
pan: rate 243677.88 states/second

39
ReversalModel/trace_seq_eq_parallel_6_3_6.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 244 byte, depth reached 245, errors: 0
437210 states, stored
253477 states, matched
690687 transitions (= stored+matched)
0 atomic steps
hash conflicts: 1607 (resolved)
Stats on memory usage (in Megabytes):
113.412 equivalent memory usage for states (stored*(State-vector + overhead))
92.748 actual memory usage for states (compression: 81.78%)
state-vector as stored = 194 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
221.112 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_6_3_6.pml:87, state 75, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_6_3_6.pml:91, state 85, "-end-"
(2 of 85 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 1.99 seconds
pan: rate 219703.52 states/second

39
ReversalModel/trace_seq_eq_parallel_6_3_7.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 244 byte, depth reached 245, errors: 0
652580 states, stored
378368 states, matched
1030948 transitions (= stored+matched)
0 atomic steps
hash conflicts: 3547 (resolved)
Stats on memory usage (in Megabytes):
169.279 equivalent memory usage for states (stored*(State-vector + overhead))
138.299 actual memory usage for states (compression: 81.70%)
state-vector as stored = 194 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
266.620 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_6_3_7.pml:87, state 76, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_6_3_7.pml:91, state 86, "-end-"
(2 of 86 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 3.37 seconds
pan: rate 193643.92 states/second

39
ReversalModel/trace_seq_eq_parallel_6_3_8.txt Normal file
View file

@ -0,0 +1,39 @@
pan: ltl formula seq_eq_parallel
(Spin Version 6.5.2 -- 6 December 2019)
+ Partial Order Reduction
Full statespace search for:
never claim + (seq_eq_parallel)
assertion violations + (if within scope of claim)
acceptance cycles + (fairness disabled)
invalid end states - (disabled by never claim)
State-vector 244 byte, depth reached 245, errors: 0
929110 states, stored
538731 states, matched
1467841 transitions (= stored+matched)
0 atomic steps
hash conflicts: 7338 (resolved)
Stats on memory usage (in Megabytes):
241.011 equivalent memory usage for states (stored*(State-vector + overhead))
196.752 actual memory usage for states (compression: 81.64%)
state-vector as stored = 194 byte + 28 byte overhead
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
325.019 total actual memory usage
unreached in proctype ThreadedReverser
(0 of 15 states)
unreached in init
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_6_3_8.pml:87, state 77, "seq_eq_to_parallel = 0"
/Users/maggicl/git/soft-an/assignment-4/ReversalModel/reversal_seq_eq_parallel_6_3_8.pml:91, state 87, "-end-"
(2 of 87 states)
unreached in claim seq_eq_parallel
_spin_nvr.tmp:8, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 3.66 seconds
pan: rate 253855.19 states/second

Some files were not shown because too many files have changed in this diff Show more