mersenneforum.org

mersenneforum.org (https://www.mersenneforum.org/index.php)
-   Data (https://www.mersenneforum.org/forumdisplay.php?f=21)
-   -   Most popular error codes (https://www.mersenneforum.org/showthread.php?t=1111)

GP2 2003-09-14 15:50

Most popular error codes
 
Most popular error codes in LUCAS_V.TXT and their frequency (Sept 9 2003 data)

Reminder: LUCAS_V.TXT contains verified-good results.

[code]
count error code
------ --------
286111 00000000
224985
8455 80000000
1876 00010000
1659 00000001
702 00020000
395 00030000
365 00000100
272 01000100
262 00000002
250 00040000
195 00050000
168 02000200
143 00060000
139 01000001
123 03000300
120 01000000
119 00070000
117 00010001
116 80010000
115 00000003
95 00080000
68 000A0000
[/code]

Linux (Unix) command to generate the above:
cut -d , -f 7 LUCAS_V.TXT | sort | uniq -c | sort -k 1 -n -r | less
(Use the "more" command if the "less" command doesn't exist on your system)

Note:
- There are a lot of old results with blank (no) error code.
- Results sometimes still turn out to be good even with errors.

GP2 2003-09-14 15:55

Most popular error codes in BAD and their frequency (Sept 9 2003 data)

Reminder: BAD contains verified-bad results.

[code]
count error code
------ --------
5011 00000000
4397
500 00000001
354 80000000
243 00000100
239 00000002
104 00000003
98 00000101
76 00000004
73 00000200
67 00010000
57 00000005
48 00000102
43 00000006
37 01000000
36 00000300
35 00000103
30 00000201
30 00000008
28 00020000
28 00010001
25 00000007
24 80000001
[/code]

Linux (Unix) command to generate the above:
cut -d , -f 7 BAD | sort | uniq -c | sort -k 1 -n -r | less
(Use the "more" command if the "less" command doesn't exist on your system)

Note:
- There are a lot of old results with blank (no) error code.
- Results sometimes still turn out to be bad even with zero error code. In fact, a bad result is much more likely to have zero error code than any other error code.

GP2 2003-09-14 16:02

Most popular error codes for BAD and LUCAS_V.TXT combined (Sept 9 2003 data),
sorted in reverse order of total occurrences of each error code.

[code]
err code bad good total bad/total
-------- ---- ----- ------ ----
00000000 5011 286111 291122 .017
*BLANK** 4397 224985 229382 .019
80000000 354 8455 8809 .040
00000001 500 1659 2159 .231
00010000 67 1876 1943 .034
00020000 28 702 730 .038
00000100 243 365 608 .399
00000002 239 262 501 .477
00030000 5 395 400 .012
01000100 5 272 277 .018
00040000 15 250 265 .056
00000003 104 115 219 .474
00050000 5 195 200 .025
02000200 5 168 173 .028
00000101 98 65 163 .601
01000000 37 120 157 .235
00060000 5 143 148 .033
00010001 28 117 145 .193
01000001 0 139 139 0
00000004 76 61 137 .554
80010000 13 116 129 .100
03000300 2 123 125 .016
00070000 5 119 124 .040
00000200 73 39 112 .651
00080000 3 95 98 .030
00000005 57 40 97 .587
00000006 43 32 75 .573
00000102 48 26 74 .648
00020001 10 63 73 .136
000A0000 2 68 70 .028
00090000 1 68 69 .014
04000400 2 66 68 .029
00010002 24 34 58 .413
000B0000 1 56 57 .017
80000001 24 31 55 .436
05000500 3 51 54 .055
000D0000 2 49 51 .039
[/code]

Even if your error code was zero, you have a 1.7% chance of returning a bad result.

smh 2003-09-14 16:02

Now we only need to know what each error means.

I seem to remember that there are 4 counters of 2 (base 10? ) digits in there?

GP2 2003-09-14 16:13

Finally, take the top 50 most frequently occuring error codes in BAD and LUCAS_V.TXT combined, and sort them in order of increasing (bad/total) ratio (Sept 9 2003 data).

[code]
err code bad good total bad/total
-------- ---- ----- ------ ----
01000001 0 139 139 0
00030000 5 395 400 .012
00090000 1 68 69 .014
03000300 2 123 125 .016
00000000 5011 286111 291122 .017
000B0000 1 56 57 .017
01000100 5 272 277 .018
*BLANK** 4397 224985 229382 .019
00050000 5 195 200 .025
000E0000 1 37 38 .026
00100000 1 37 38 .026
000A0000 2 68 70 .028
02000200 5 168 173 .028
04000400 2 66 68 .029
00080000 3 95 98 .030
000C0000 1 32 33 .030
00060000 5 143 148 .033
00010000 67 1876 1943 .034
00020000 28 702 730 .038
000D0000 2 49 51 .039
00070000 5 119 124 .040
80000000 354 8455 8809 .040
000F0000 2 34 36 .055
02000002 2 34 36 .055
05000500 3 51 54 .055
00040000 15 250 265 .056
80010000 13 116 129 .100
80020000 5 37 42 .119
00020001 10 63 73 .136
00030001 8 34 42 .190
00010001 28 117 145 .193
00000001 500 1659 2159 .231
01000000 37 120 157 .235
00000100 243 365 608 .399
00010002 24 34 58 .413
80000001 24 31 55 .436
00000003 104 115 219 .474
00000002 239 262 501 .477
00000004 76 61 137 .554
00000007 25 19 44 .568
00000006 43 32 75 .573
00000005 57 40 97 .587
0000000A 21 14 35 .600
00000101 98 65 163 .601
00000201 30 18 48 .625
00000008 30 17 47 .638
00000102 48 26 74 .648
00000200 73 39 112 .651
00000103 35 12 47 .744
00000300 36 12 48 .750
[/code]

Oddly enough you seem to have a better chance of returning a good result with an error code of 01000001 than with a zero error code. Though of course this is not statistically significant with only 139 total results having this error code.

NickGlover 2003-09-14 19:31

I'm guessing the results with blank error codes are from different programs (not George's) and older versions that didn't return the error code.

Note that error codes of the form 0X000X00 typically indicate repeatable (i.e. not a hardware problem) roundoff errors that were corrected by using a slower, more accurate method for the iteration in question. These only occur near the FFT limits. Tests with these error codes shouldn't be much more likely to be bad than normal tests.

Prime95 2003-09-14 21:45

Error analysis is trickier than the results posted thusfar.

1) Version WUx had a bug where the errors were not counted properly. So many of the 00000000 reports really had errors.

2) 80000000 means some of the run occured with a version that did not count errors and some of the run was with a version that did count errors.

3) As someone already noted, the top byte indicates repeatable errors. This is quite normal near the upper limits of each FFT length.

GP2 2003-09-14 22:16

[QUOTE][i]Originally posted by Prime95 [/i]
[B]
1) Version WUx had a bug where the errors were not counted properly. So many of the 00000000 reports really had errors.
[/B][/QUOTE]

OK, we can partly re-do the analysis eliminating those cases where the program used was WUx.

The odds of getting a bad result even when the error code was zero:

Old estimate: 5011/(5011+286111) = .017 [results from all programs]
New estimate: 2536/(2536+212157) = .011 [excluding results from program WUx]


GP2 2003-09-14 22:50

Results for which the error code was zero,
broken down by the type of program that returned them:

Note:
xx0 = Win 3.1
xx1 = Win 95
xx2 = Linux
xx5 = Win NT service
xx6 = FreeBSD
xx7 = OS/2

[code]
prog bad good total bad/total
--- ---- ----- ----- -----

G29 1 0 1 1.000

WT1 294 24768 25062 .011
WT2 39 4290 4329 .009
WT5 29 5236 5265 .005
WT7 1 124 125 .008

WU0 1 23 24 .041
WU1 1934 47911 49845 .038
WU2 355 11324 11679 .030
WU5 170 14032 14202 .011
WU7 15 664 679 .022

WV1 463 30893 31356 .014
WV2 123 7504 7627 .016
WV5 74 10133 10207 .007
WV6 10 451 461 .021

WW1 326 29098 29424 .011
WW2 131 10278 10409 .012
WW5 71 10261 10332 .006

WX1 368 24326 24694 .014
WX2 106 8917 9023 .011
WX5 103 7679 7782 .013
WX6 8 237 245 .032

WY1 271 18711 18982 .014
WY2 51 5915 5966 .008
WY5 5 4849 4854 .001
WY6 1 96 97 .010
WY7 0 13 13 0

WZ1 59 6136 6195 .009
WZ2 2 1808 1810 .001
WZ5 0 408 408 0
WZ6 0 17 17 0
WZ7 0 9 9 0
[/code]

We can see the spike in the error rate for WUx. Other than that, the data don't seem to show anything.


Note again: this is for results [b]where the error code was zero[/b]. The overall error rate is higher, since nonzero error codes sometimes (often) produce higher rates of error.

apocalypse 2003-09-15 23:03

As far as I can tell, the last digit in the error code seems to be a count of SUMIN != SUMOUT errors.

only_human 2003-12-26 11:50

I've tried to rearrange the data in this thread according to error type.
[code]

error code = AABBCCDD (in hex)

AA = top bit on means "test was started using a version that did not count errors", remaining 7 bits is count of errors that were reproducible.
BB = count of ILLEGAL SUMOUTS
CC = count of round off > 0.4 errors
DD = count of SUM(IMPUTS) != SUM (OUTPUTS)


err code bad good total bad/total
-------- ---- ----- ------ ----
00000000 2536 212157 214693 .011 [excluding results from program WUx]
00000000 5011 286111 291122 .017 [results from all programs]
*BLANK** 4397 224985 229382 .019


ILLEGAL SUMOUTS
err code bad good total bad/total
-------- ---- ----- ------ ----
00010000 67 1876 1943 .034
00020000 28 702 730 .038
00030000 5 395 400 .012
00040000 15 250 265 .056
00050000 5 195 200 .025
00060000 5 143 148 .033
00070000 5 119 124 .040
00080000 3 95 98 .030
00090000 1 68 69 .014
000A0000 2 68 70 .028
000B0000 1 56 57 .017
000C0000 1 32 33 .030
000D0000 2 49 51 .039
000E0000 1 37 38 .026
000F0000 2 34 36 .055


round off > 0.4 errors --- that had a "reproduceable" count in the most significant byte.
err code bad good total bad/total
-------- ---- ----- ------ ----
01000100 5 272 277 .018
02000200 5 168 173 .028
03000300 2 123 125 .016
04000400 2 66 68 .029
05000500 3 51 54 .055

round off > 0.4 errors
err code bad good total bad/total
-------- ---- ----- ------ ----
00000100 243 365 608 .399
00000200 73 39 112 .651
00000300 36 12 48 .750


SUM(INPUTS) != SUM(OUTPUTS) --- that had a "reproduceable" count in the most significant byte.
01000001 0 139 139 0
02000002 2 34 36 .055

SUM(INPUTS) != SUM(OUTPUTS)
err code bad good total bad/total
-------- ---- ----- ------ ----
00000001 500 1659 2159 .231
00000002 239 262 501 .477
00000003 104 115 219 .474
00000004 76 61 137 .554
00000005 57 40 97 .587
00000006 43 32 75 .573
00000007 25 19 44 .568
00000008 30 17 47 .638
...
0000000A 21 14 35 .600


MIXED ERRORS
err code bad good total bad/total
-------- ---- ----- ------ ----
00010001 28 117 145 .193 1 ILLEGAL SUMOUT error , also 1 SUM(INPUTS) != SUM(OUTPUTS) error
00020001 10 63 73 .136 2 ILLEGAL SUMOUT errors, also 1 SUM(INPUTS) != SUM(OUTPUTS) error
00010002 24 34 58 .413 1 ILLEGAL SUMOUT error , also 2 SUM(INPUTS) != SUM(OUTPUTS) errors
00000101 98 65 163 .601 1 round off > 0.4 error, also 1 SUM(INPUTS) != SUM(OUTPUTS) error
00000102 48 26 74 .648 1 round off > 0.4 error, also 2 SUM(INPUTS) != SUM(OUTPUTS) errors
00000103 35 12 47 .744 1 round off > 0.4 error, also 3 SUM(INPUTS) != SUM(OUTPUTS) errors


Tests started with a version that did not count errors.
err code bad good total bad/total
-------- ---- ----- ------ ----
80000000 354 8455 8809 .040 test was started using a version that did not count errors
80010000 13 116 129 .100 1 ILLEGAL SUMOUT error
80020000 5 37 42 .119 2 ILLEGAL SUMOUT errors
80000001 24 31 55 .436 1 SUM(INPUTS) != SUM(OUTPUTS) error


I am unsure about the meaning of this error code
err code bad good total bad/total
-------- ---- ----- ------ ----
01000000 37 120 157 .235
[/code]


All times are UTC. The time now is 11:16.

Powered by vBulletin® Version 3.8.11
Copyright ©2000 - 2020, Jelsoft Enterprises Ltd.