This is the mail archive of the libc-alpha@sourceware.org mailing list for the glibc project.
| Index Nav: | [Date Index] [Subject Index] [Author Index] [Thread Index] | |
|---|---|---|
| Message Nav: | [Date Prev] [Date Next] | [Thread Prev] [Thread Next] |
| Other format: | [Raw text] | |
Hi!
This turned into a general analysis of (parts of) SH's math/*.out
results. Also, perhaps there's a testsuite harness oddity -- seach for
Âverbose in the following text if you want to skip the (probably)
SH-specific bits.
On Thu, 17 May 2012 10:07:00 +0900, Kaz Kojima <kkojima@rr.iij4u.or.jp> wrote:
> Thomas Schwinge <thomas@codesourcery.com> wrote:
> > With these patches applied, while there is also some improvement visible
> > in the test results, I'm seeing a lot more failures in the math/*
> > testsuites than without them. I just re-confirmed this in the current
> > source tree with the patches reverted. As I have no knowledge about math
> > exception handling but you evidently do -- would it be possible for you
> > to review that situation?
> >
> > For example, diff of current source tree vs. current source tree with
> > these four patches reverted:
>
> I haven't seen any differences in test results for those
> patches. Surely I did something wrong when testing them.
Ho, likewise there might be something wrong in my setup, too. :-)
If you want, you could send me your math/*.out files, and I could compare
with mine.
> It looks that almost new failures come from fraiseexcpt change:
>
> http://sourceware.org/ml/libc-alpha/2012-04/msg00165.html
>
> It seems that now instructions to raise execptions clear old
> exception flag fields. A quick fix maybe
>
> --- ORIG/libc/sysdeps/sh/sh4/fpu/fraiseexcpt.c 2012-05-17 09:50:58.000000000 +0900
> +++ libc/sysdeps/sh/sh4/fpu/fraiseexcpt.c 2012-05-17 09:50:34.000000000 +0900
> @@ -60,6 +60,14 @@ feraiseexcept (int excepts)
> __asm__ __volatile__ ("fmul %1, %0" : "+d" (d) : "d" (x));
> }
>
> + /* Restore flag fields. */
> + {
> + fexcept_t temp;
> + _FPU_GETCW (temp);
> + temp |= (excepts & FE_ALL_EXCEPT);
> + _FPU_SETCW (temp);
> + }
> +
> return 0;
> }
> libm_hidden_def (feraiseexcept)
Yes, that indeed helps, thanks!
math/test-fenv.out:
[...]
-61 errors occurred.
+6 errors occurred.
Similarly, a lot of failures disappear from math/test-float.out:
[...]
Test suite completed:
3832 test cases plus 3388 tests for exception flags executed.
- 520 errors occurred.
+ 420 errors occurred.
In the following, [old] means that this was already present without Kaz'
recent patch. When I say new, this is a recent tree including both
Nobuhiro's patches and Kaz' recent patch.
[old] Several exception-realated issues remain in math/test-float.out
(but some of these (didn't compare all) were not present before
Nobuhiro's patches went in):
Failure: cos (inf) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: cos (-inf) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: sin (inf) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: sin (-inf) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: sincos (inf, &sin_res, &cos_res) puts NaN in sin_res plus invalid exception: Exception "Invalid operation" not set
Failure: sincos (-inf, &sin_res, &cos_res) puts NaN in sin_res plus invalid exception: Exception "Invalid operation" not set
Failure: tan (inf) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: tan (-inf) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: acosh (-inf) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: acosh (-1.125) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: acosh (-max_value) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: atanh (1) == inf plus division by zero exception: Exception "Divide by zero" not set
Failure: atanh (-1) == -inf plus division by zero exception: Exception "Divide by zero" not set
Failure: atanh (1.125) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: atanh (-1.125) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: atanh (max_value) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: atanh (-max_value) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: exp (710) == inf plus overflow exception: Exception "Overflow" not set
Failure: exp (1e5) == inf plus overflow exception: Exception "Overflow" not set
Failure: exp (max_value) == inf plus overflow exception: Exception "Overflow" not set
Failure: exp2 (1e6) == inf plus overflow exception: Exception "Overflow" not set
Failure: exp2 (max_value) == inf plus overflow exception: Exception "Overflow" not set
Failure: expm1 (100000.0) == inf plus overflow exception: Exception "Overflow" not set
Failure: expm1 (max_value) == inf plus overflow exception: Exception "Overflow" not set
Failure: log1p (-1) == -inf plus division by zero exception: Exception "Divide by zero" not set
Failure: log1p (-2) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: log1p (-max_value) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: log1p (-inf) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: logb (0) == -inf plus division by zero exception: Exception "Divide by zero" not set
Failure: logb (-0) == -inf plus division by zero exception: Exception "Divide by zero" not set
Failure: scalb (0, inf) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: scalb (-0, inf) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: scalb (inf, -inf) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: scalb (-inf, -inf) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: scalbn (1, INT_MAX) == inf plus overflow exception: Exception "Overflow" not set
Failure: scalbn (max_value, INT_MAX) == inf plus overflow exception: Exception "Overflow" not set
Failure: scalbn (min_value, INT_MAX) == inf plus overflow exception: Exception "Overflow" not set
Failure: scalbn (min_value / 4, INT_MAX) == inf plus overflow exception: Exception "Overflow" not set
Failure: scalbln (1, INT_MAX) == inf plus overflow exception: Exception "Overflow" not set
Failure: scalbln (max_value, INT_MAX) == inf plus overflow exception: Exception "Overflow" not set
Failure: scalbln (min_value, INT_MAX) == inf plus overflow exception: Exception "Overflow" not set
Failure: scalbln (min_value / 4, INT_MAX) == inf plus overflow exception: Exception "Overflow" not set
Failure: scalbln (1, LONG_MAX) == inf plus overflow exception: Exception "Overflow" not set
Failure: scalbln (max_value, LONG_MAX) == inf plus overflow exception: Exception "Overflow" not set
Failure: scalbln (min_value, LONG_MAX) == inf plus overflow exception: Exception "Overflow" not set
Failure: scalbln (min_value / 4, LONG_MAX) == inf plus overflow exception: Exception "Overflow" not set
Failure: pow (-0.1, 1.1) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: pow (-0.1, -1.1) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: pow (-10.1, 1.1) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: pow (-10.1, -1.1) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: pow (0, -1) == inf plus division by zero exception: Exception "Divide by zero" not set
Failure: pow (0, -11) == inf plus division by zero exception: Exception "Divide by zero" not set
Failure: pow (0, -0xffffff) == inf plus division by zero exception: Exception "Divide by zero" not set
Failure: pow (-0, -1) == -inf plus division by zero exception: Exception "Divide by zero" not set
Failure: pow (-0, -11) == -inf plus division by zero exception: Exception "Divide by zero" not set
Failure: pow (-0, -0xffffff) == -inf plus division by zero exception: Exception "Divide by zero" not set
Failure: pow (-0, -0x1fffffe) == inf plus division by zero exception: Exception "Divide by zero" not set
Failure: pow (0, -2) == inf plus division by zero exception: Exception "Divide by zero" not set
Failure: pow (0, -11.1) == inf plus division by zero exception: Exception "Divide by zero" not set
Failure: pow (0, -0x1p24) == inf plus division by zero exception: Exception "Divide by zero" not set
Failure: pow (0, -0x1p127) == inf plus division by zero exception: Exception "Divide by zero" not set
Failure: pow (0, -max_value) == inf plus division by zero exception: Exception "Divide by zero" not set
Failure: pow (-0, -2) == inf plus division by zero exception: Exception "Divide by zero" not set
Failure: pow (-0, -11.1) == inf plus division by zero exception: Exception "Divide by zero" not set
Failure: pow (-0, -0x1p24) == inf plus division by zero exception: Exception "Divide by zero" not set
Failure: pow (-0, -0x1p127) == inf plus division by zero exception: Exception "Divide by zero" not set
Failure: pow (-0, -max_value) == inf plus division by zero exception: Exception "Divide by zero" not set
Failure: pow (0x1p72, 0x1p72) == inf plus overflow exception: Exception "Overflow" not set
Failure: pow (max_value, max_value) == inf plus overflow exception: Exception "Overflow" not set
Failure: pow (-2.0, 0xffffff) == -inf plus overflow exception: Exception "Overflow" not set
Failure: pow (-2.0, 0x1fffffe) == inf plus overflow exception: Exception "Overflow" not set
Failure: pow (-2.0, max_value) == inf plus overflow exception: Exception "Overflow" not set
Failure: pow (-max_value, 0.5) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: pow (-max_value, 1.5) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: pow (-max_value, 1000.5) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: pow (-max_value, 2) == inf plus overflow exception: Exception "Overflow" not set
Failure: pow (-max_value, 3) == -inf plus overflow exception: Exception "Overflow" not set
Failure: pow (-max_value, 0xffffff) == -inf plus overflow exception: Exception "Overflow" not set
Failure: pow (-max_value, 0x1fffffe) == inf plus overflow exception: Exception "Overflow" not set
Failure: pow (-max_value, max_value) == inf plus overflow exception: Exception "Overflow" not set
Failure: pow (-0.5, -0xffffff) == -inf plus overflow exception: Exception "Overflow" not set
Failure: pow (-0.5, -0x1fffffe) == inf plus overflow exception: Exception "Overflow" not set
Failure: pow (-0.5, -max_value) == inf plus overflow exception: Exception "Overflow" not set
Failure: pow (-min_value, 0.5) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: pow (-min_value, 1.5) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: pow (-min_value, 1000.5) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: pow (-min_value, -2) == inf plus overflow exception: Exception "Overflow" not set
Failure: pow (-min_value, -3) == -inf plus overflow exception: Exception "Overflow" not set
Failure: pow (-min_value, -0xffffff) == -inf plus overflow exception: Exception "Overflow" not set
Failure: pow (-min_value, -0x1fffffe) == inf plus overflow exception: Exception "Overflow" not set
Failure: pow (-min_value, -max_value) == inf plus overflow exception: Exception "Overflow" not set
Failure: sqrt (-1) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: sqrt (-max_value) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: sqrt (-inf) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: gamma (0) == inf plus division by zero exception: Exception "Divide by zero" not set
Failure: gamma (-3) == inf plus division by zero exception: Exception "Divide by zero" not set
Failure: lgamma (0) == inf plus division by zero exception: Exception "Divide by zero" not set
Failure: lgamma (-0) == inf plus division by zero exception: Exception "Divide by zero" not set
Failure: lgamma (-3) == inf plus division by zero exception: Exception "Divide by zero" not set
Failure: lgamma (-max_value) == inf plus division by zero exception: Exception "Divide by zero" not set
Failure: lgamma (max_value) == inf plus overflow exception: Exception "Overflow" not set
Failure: tgamma (max_value) == inf plus overflow exception: Exception "Overflow" not set
Failure: tgamma (0) == inf plus division by zero exception: Exception "Divide by zero" not set
Failure: tgamma (-0) == -inf plus division by zero exception: Exception "Divide by zero" not set
Failure: tgamma (-2) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: tgamma (-max_value) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: tgamma (-inf) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: fmod (inf, 3) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: fmod (-inf, 3) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: fmod (3, 0) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: fmod (3, -0) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: remainder (1, 0) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: remainder (1, -0) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: remainder (inf, 1) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: remainder (-inf, 1) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: remquo (1, 0, &x) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: remquo (1, -0, &x) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: remquo (inf, 1, &x) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: remquo (-inf, 1, &x) == NaN plus invalid exception: Exception "Invalid operation" not set
Failure: nextafter (fltmax, inf) == inf plus overflow exception: Exception "Overflow" not set
Failure: nextafter (-fltmax, -inf) == -inf plus overflow exception: Exception "Overflow" not set
Failure: Real part of: cexp (180 + 0x1p-149 i) == inf + 2.087071793345235105931967606907855310664e33 i plus overflow exception: Exception "Overflow" not set
Failure: Real part of: cexp (1e6 + 0 i) == inf + 0 i plus overflow exception: Exception "Overflow" not set
Failure: Real part of: cexp (1e6 + min_value i) == inf + inf i plus overflow exception: Exception "Overflow" not set
Failure: Real part of: cexp (1e6 - min_value i) == inf - inf i plus overflow exception: Exception "Overflow" not set
Failure: Real part of: clog10 (-0 + 0 i) == -inf + pi i plus division by zero exception: Exception "Divide by zero" not set
Failure: Real part of: clog10 (-0 - 0 i) == -inf - pi i plus division by zero exception: Exception "Divide by zero" not set
Failure: Real part of: clog10 (0 + 0 i) == -inf + 0.0 i plus division by zero exception: Exception "Divide by zero" not set
Failure: Real part of: clog10 (0 - 0 i) == -inf - 0 i plus division by zero exception: Exception "Divide by zero" not set
Failure: Real part of: clog (-0 + 0 i) == -inf + pi i plus division by zero exception: Exception "Divide by zero" not set
Failure: Real part of: clog (-0 - 0 i) == -inf - pi i plus division by zero exception: Exception "Divide by zero" not set
Failure: Real part of: clog (0 + 0 i) == -inf + 0.0 i plus division by zero exception: Exception "Divide by zero" not set
Failure: Real part of: clog (0 - 0 i) == -inf - 0 i plus division by zero exception: Exception "Divide by zero" not set
math/test-float.out:
[old] The rint_downward, rint_upward, lrint_downward, lrint_upward,
llrint_downward, llrint_upward functions round towards the wrong end.
math/test-float.out:
There are now also new failures showing up -- having Âexp10 (x) == xÂ
surely must be a cheap operation -- but I have no idea off-hand how that
could be due to Kaz' exception handling change? (Perhaps there are
exceptions involved in intermediate computations, and then things go
wrong?)
Failure: Test: exp10 (3) == 1000
Result:
is: 3.00000000000000000000e+00 0x1.80000000000000000000p+1
should be: 1.00000000000000000000e+03 0x1.f4000000000000000000p+9
difference: 9.97000000000000000000e+02 0x1.f2800000000000000000p+9
ulp : 16334848.0000
max.ulp : 2.0000
Failure: Test: exp10 (-1) == 0.1
Result:
is: -1.00000000000000000000e+00 -0x1.00000000000000000000p+0
should be: 1.00000001490116119385e-01 0x1.99999a00000000000000p-4
difference: 1.10000002384185791016e+00 0x1.19999a00000000000000p+0
ulp : 147639504.0000
max.ulp : 1.0000
Failure: Test: exp10 (36) == 1.0e36
Result:
is: 3.60000000000000000000e+01 0x1.20000000000000000000p+5
should be: 9.99999961690316245365e+35 0x1.812f9c00000000000000p+119
difference: 9.99999961690316245365e+35 0x1.812f9c00000000000000p+119
ulp : 12621774.0000
max.ulp : 0.0000
Failure: Test: exp10 (-36) == 1.0e-36
Result:
is: -3.60000000000000000000e+01 -0x1.20000000000000000000p+5
should be: 1.00000003593912982384e-36 0x1.54484a00000000000000p-120
difference: 3.60000000000000000000e+01 0x1.20000000000000000000p+5
ulp : inf
max.ulp : 0.0000
Failure: Test: exp10 (1e6) == inf plus overflow exception
Result:
is: 1.00000000000000000000e+06 0x1.e8480000000000000000p+19
should be: inf inf
Failure: Test: exp10 (-1e6) == 0
Result:
is: -1.00000000000000000000e+06 -0x1.e8480000000000000000p+19
should be: 0.00000000000000000000e+00 0x0.00000000000000000000p+0
difference: 1.00000000000000000000e+06 0x1.e8480000000000000000p+19
ulp : 8388608000000.0000
max.ulp : 0.0000
Failure: Test: exp10 (max_value) == inf plus overflow exception
Result:
is: 3.40282346638528859812e+38 0x1.fffffe00000000000000p+127
should be: inf inf
Failure: Test: exp10 (-max_value) == 0
Result:
is: -3.40282346638528859812e+38 -0x1.fffffe00000000000000p+127
should be: 0.00000000000000000000e+00 0x0.00000000000000000000p+0
difference: 3.40282346638528859812e+38 0x1.fffffe00000000000000p+127
ulp : inf
max.ulp : 0.0000
Failure: Test: exp10 (0.75) == 5.62341325190349080394951039776481231
Result:
is: 7.50000000000000000000e-01 0x1.80000000000000000000p-1
should be: 5.62341308593750000000e+00 0x1.67e60000000000000000p+2
difference: 4.87341308593750000000e+00 0x1.37e60000000000000000p+2
ulp : 10220288.0000
max.ulp : 0.0000
Maximal error of `exp10'
is : inf ulp
accepted: 2 ulp
Failure: Test: fma (inf, inf, -inf) == NaN plus invalid exception
Result:
is: -inf -inf
should be: nan nan
Failure: Test: fma (-inf, inf, inf) == NaN plus invalid exception
Result:
is: inf inf
should be: nan nan
Failure: Test: fma (inf, -inf, inf) == NaN plus invalid exception
Result:
is: inf inf
should be: nan nan
Failure: Test: fma (-inf, -inf, -inf) == NaN plus invalid exception
Result:
is: -inf -inf
should be: nan nan
Failure: Test: fma (inf, 3.5, -inf) == NaN plus invalid exception
Result:
is: -inf -inf
should be: nan nan
Failure: Test: fma (-inf, -7.5, -inf) == NaN plus invalid exception
Result:
is: -inf -inf
should be: nan nan
Failure: Test: fma (-13.5, inf, inf) == NaN plus invalid exception
Result:
is: inf inf
should be: nan nan
Failure: Test: fma (-inf, 7.5, inf) == NaN plus invalid exception
Result:
is: inf inf
should be: nan nan
Failure: Test: fma (0x1.7ff8p+13, 0x1.000002p+0, 0x1.ffffp-24) == 0x1.7ff802p+13
Result:
is: 1.19208380056079477072e-07 0x1.ffff0000000000000000p-24
should be: 1.22870009765625000000e+04 0x1.7ff80200000000000000p+13
difference: 1.22870009765625000000e+04 0x1.7ff80200000000000000p+13
ulp : 12581889.0000
max.ulp : 0.0000
math/test-double.out:
[old] The tests for acos, acos_tonearest, acos_towardzero, acos_downward,
acos_upward, asin return nonsensical results.
(51327489295686790529285095424 ulp, anyone?) ;-)
Perhaps related to that:
Failure: asin (0x0.ffffffp0) == 1.5704510598101804156437184421571127056013: Exception "Invalid operation" set
Failure: asin (0x0.ffffffp0) == 1.5704510598101804156437184421571127056013: Exception "Overflow" set
Failure: asin (0x0.ffffffff8p0) == 1.5707810680058339712015850710748035974710: Exception "Invalid operation" set
Failure: asin (0x0.ffffffff8p0) == 1.5707810680058339712015850710748035974710: Exception "Overflow" set
Failure: asin (0x0.ffffffffffffp0) == 1.5707962425011995974432331617542781977068: Exception "Invalid operation" set
Failure: asin (0x0.ffffffffffffp0) == 1.5707962425011995974432331617542781977068: Exception "Overflow" set
The math/test-double.out testsuite terminates after printing the first
bits of the atan test results. Running it manually, I see the (faulty)
results for Âatan (inf)Â and Âatan (NaN)Â, and then it hangs, eating 100
% CPU time. Specifying Â--verbose=1Â makes it complete after 37 s.
Strange. That log does *not* show the bugs acos results cited above
(huh?), but instead shows several more exception-related failures, and
again the issues with exp10 and fma as well as rint_downward et al., and
likewise for erf, erfc, ccos including some Âinfinity has wrong signÂ
occurrences.
To reiterate, the (successful) run with Â--verbose=1Â has this:
atan (inf) == pi/2: Exception "Divide by zero" not set
atan (inf) == pi/2: Exception "Invalid operation" not set
atan (inf) == pi/2: Exception "Overflow" not set
Test: atan (inf) == pi/2
Result:
is: 1.57079632679489655800e+00 0x1.921fb54442d180000000p+0
should be: 1.57079632679489655800e+00 0x1.921fb54442d180000000p+0
difference: 0.00000000000000000000e+00 0x0.00000000000000000000p+0
ulp : 0.0000
max.ulp : 0.0000
atan (-inf) == -pi/2: Exception "Divide by zero" not set
atan (-inf) == -pi/2: Exception "Invalid operation" not set
atan (-inf) == -pi/2: Exception "Overflow" not set
Test: atan (-inf) == -pi/2
Result:
is: -1.57079632679489655800e+00 -0x1.921fb54442d180000000p+0
should be: -1.57079632679489655800e+00 -0x1.921fb54442d180000000p+0
difference: 0.00000000000000000000e+00 0x0.00000000000000000000p+0
ulp : 0.0000
max.ulp : 0.0000
..., where as the regular run (testsuite or without Â--verbose=1Â) shows:
Failure: atan (inf) == pi/2: Exception "Invalid operation" set
Failure: Test: atan (inf) == pi/2
Result:
is: -1.57079632679489655800e+00 -0x1.921fb54442d180000000p+0
should be: 1.57079632679489655800e+00 0x1.921fb54442d180000000p+0
difference: 4.02123859659493518848e+02 0x1.921fb54442d180000000p+8
ulp : 5963735302941976.0000
max.ulp : 0.0000
..., then continues with ÂFailure: Test: atan (NaN) == NaNÂ, and then
busy-loops. Also, notice the two missing exceptions, and the swapped
sign/result of atan (-inf) for atan (inf). Might all be coincidence, or
is there something wrong in the test harness itself?
math/test-ifloat.out:
Also shows the (new) exp10 and fma failures cited before.
Also shows the rint_downward, rint_upward, lrint_downward, lrint_upward,
llrint_downward, llrint_upward failures cited before.
No exception-related failures here, it seems.
math/test-idouble.out:
New with Kaz' patch: The tests for acos, cos, cos_tonearest,
cos_towardzero, cos_downward, cos_upward return nonsensical results.
And there is also a ÂBus error after ÂFailure: Test: sin (-pi/6) ==
-0.5Â, and the test terminates (after 1 min 22 s). Running with
Â--verbose=1 the ÂBus error reproducibly occurs after ÂTest: pow (-0,
-11.1) == inf plus division by zero exception (after 15 s). Accoding to
dmesg, ÂSending SIGBUS to "ld-linux.so.2" due to unaligned access (PC
404d46 PR 404d4a)Â.
math/test-dbl-wrap.out used to pass, now times out (testsuite)/doesn't
finish (if run with Â--directÂ; I killed it after having eaten 6 min CPU
time).
math/atest-exp.out:
131071 failures; 0 errors; error rate 0.00%
maximum error: efffeffff7fffd5554aaaa888882d82cc
error in exp(1): 00000000000000000000000cbffc1f5e9
This is new; used to pass.
math/atest-sincos.out now also seems to get stuck in some kind of
busy-loop.
GrÃÃe,
Thomas
Attachment:
pgp00000.pgp
Description: PGP signature
| Index Nav: | [Date Index] [Subject Index] [Author Index] [Thread Index] | |
|---|---|---|
| Message Nav: | [Date Prev] [Date Next] | [Thread Prev] [Thread Next] |