This is the mail archive of the
libc-alpha@sourceware.org
mailing list for the glibc project.
[PATCH] Implement fma correctly
- From: Jakub Jelinek <jakub at redhat dot com>
- To: libc-alpha at sources dot redhat dot com
- Date: Tue, 12 Oct 2010 21:16:05 +0200
- Subject: [PATCH] Implement fma correctly
- Reply-to: Jakub Jelinek <jakub at redhat dot com>
Hi!
This patch fixes a bug in fmaf (the union is for double, not float,
so Inf/NaN test is exponent == 0x7ff instead of == 0xff) and implements
fma (both using just double arithmetics, where I hope I got the overflow
checks right) and for IEEE quad using long double arithmetics.
Tested on x86_64-linux, it is very well possible it won't work correctly
on i686 due to excess precision. For i686 we could add a -mfpmath=sse -msse2
compiled version as yet another ifunc variant for SSE2+ and then have some
excess precision safe variant (e.g. doing the computation using 80-bit
long double somehow - we wouldn't need to deal with overflows then, but
we'd need to figure out how to do the rouding properly).
2010-10-12 Jakub Jelinek <jakub@redhat.com>
[BZ #3268]
* math/libm-test.inc (fma_test): Add some more fmaf tests, add
fma tests.
* sysdeps/ieee754/dbl-64/s_fmaf.c (__fmaf): Fix Inf/Nan check.
* sysdeps/ieee754/dbl-64/s_fma.c: New file.
* sysdeps/i386/i686/multiarch/s_fma.c: Include
sysdeps/ieee754/dbl-64/s_fma.c instead of math/s_fma.c.
* sysdeps/x86_64/multiarch/s_fma.c: Likewise.
* sysdeps/ieee754/ldbl-opt/s_fma.c: Likewise.
* sysdeps/ieee754/ldbl-128/s_fma.c: New file.
--- libc/math/libm-test.inc.jj 2010-10-12 07:36:10.000000000 +0200
+++ libc/math/libm-test.inc 2010-10-12 20:36:13.000000000 +0200
@@ -2789,9 +2789,19 @@ fma_test (void)
TEST_fff_f (fma, minus_infty, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
TEST_fff_f (fma, 1.25L, 0.75L, 0.0625L, 1.0L);
-#ifdef TEST_FLOAT
+#if defined (TEST_FLOAT) && FLT_MANT_DIG == 24
TEST_fff_f (fma, 0x1.7ff8p+13, 0x1.000002p+0, 0x1.ffffp-24, 0x1.7ff802p+13);
TEST_fff_f (fma, 0x1.fffp+0, 0x1.00001p+0, -0x1.fffp+0, 0x1.fffp-20);
+ TEST_fff_f (fma, 0x1.fffffep+127, 0x1.001p+0, -0x1.fffffep+127, 0x1.fffffep+115);
+ TEST_fff_f (fma, -0x1.fffffep+127, 0x1.fffffep+0, 0x1.fffffep+127, -0x1.fffffap+127);
+ TEST_fff_f (fma, 0x1.fffffep+127, 2.0, -0x1.fffffep+127, 0x1.fffffep+127);
+#endif
+#if defined (TEST_DOUBLE) && DBL_MANT_DIG == 53
+ TEST_fff_f (fma, 0x1.7fp+13, 0x1.0000000000001p+0, 0x1.ffep-48, 0x1.7f00000000001p+13);
+ TEST_fff_f (fma, 0x1.fffp+0, 0x1.0000000000001p+0, -0x1.fffp+0, 0x1.fffp-52);
+ TEST_fff_f (fma, 0x1.fffffffffffffp+1023, 0x1.001p+0, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+1011);
+ TEST_fff_f (fma, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+0, 0x1.fffffffffffffp+1023, -0x1.ffffffffffffdp+1023);
+ TEST_fff_f (fma, 0x1.fffffffffffffp+1023, 2.0, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+1023);
#endif
END (fma);
--- libc/sysdeps/ieee754/dbl-64/s_fmaf.c.jj 2010-10-12 07:36:10.000000000 +0200
+++ libc/sysdeps/ieee754/dbl-64/s_fmaf.c 2010-10-12 16:56:19.000000000 +0200
@@ -39,7 +39,7 @@ __fmaf (float x, float y, float z)
fesetround (FE_TOWARDZERO);
/* Perform addition with round to odd. */
u.d = temp + (double) z;
- if ((u.ieee.mantissa1 & 1) == 0 && u.ieee.exponent != 0xff)
+ if ((u.ieee.mantissa1 & 1) == 0 && u.ieee.exponent != 0x7ff)
u.ieee.mantissa1 |= fetestexcept (FE_INEXACT) != 0;
feupdateenv (&env);
/* And finally truncation with round to nearest. */
--- libc/sysdeps/ieee754/dbl-64/s_fma.c.jj 2010-10-12 15:44:44.000000000 +0200
+++ libc/sysdeps/ieee754/dbl-64/s_fma.c 2010-10-12 20:52:40.000000000 +0200
@@ -0,0 +1,140 @@
+/* Compute x * y + z as ternary operation.
+ Copyright (C) 2010 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Jakub Jelinek <jakub@redhat.com>, 2010.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#include <float.h>
+#include <math.h>
+#include <fenv.h>
+#include <ieee754.h>
+
+/* This implementation uses rounding to odd to avoid problems with
+ double rounding. See a paper by Boldo and Melquiond:
+ http://www.lri.fr/~melquion/doc/08-tc.pdf */
+
+double
+__fma (double x, double y, double z)
+{
+ union ieee754_double u, v, w;
+ int adjust = 0;
+ u.d = x;
+ v.d = y;
+ w.d = z;
+ if (__builtin_expect (u.ieee.exponent + v.ieee.exponent
+ >= 0x7ff + IEEE754_DOUBLE_BIAS - DBL_MANT_DIG, 0)
+ || __builtin_expect (u.ieee.exponent >= 0x7ff - DBL_MANT_DIG, 0)
+ || __builtin_expect (v.ieee.exponent >= 0x7ff - DBL_MANT_DIG, 0)
+ || __builtin_expect (w.ieee.exponent >= 0x7ff - DBL_MANT_DIG, 0))
+ {
+ /* If x or y or z is Inf/NaN or if fma will certainly overflow,
+ compute as x * y + z. */
+ if (u.ieee.exponent == 0x7ff
+ || v.ieee.exponent == 0x7ff
+ || w.ieee.exponent == 0x7ff
+ || u.ieee.exponent + v.ieee.exponent
+ > 0x7ff + IEEE754_DOUBLE_BIAS)
+ return x * y + z;
+ if (u.ieee.exponent + v.ieee.exponent
+ >= 0x7ff + IEEE754_DOUBLE_BIAS - DBL_MANT_DIG)
+ {
+ /* Compute 1p-53 times smaller result and multiply
+ at the end. */
+ if (u.ieee.exponent > v.ieee.exponent)
+ u.ieee.exponent -= DBL_MANT_DIG;
+ else
+ v.ieee.exponent -= DBL_MANT_DIG;
+ /* If x + y exponent is very large and z exponent is very small,
+ it doesn't matter if we don't adjust it. */
+ if (w.ieee.exponent > DBL_MANT_DIG)
+ w.ieee.exponent -= DBL_MANT_DIG;
+ adjust = 1;
+ }
+ else if (w.ieee.exponent >= 0x7ff - DBL_MANT_DIG)
+ {
+ /* Similarly.
+ If z exponent is very large and x and y exponents are
+ very small, it doesn't matter if we don't adjust it. */
+ if (u.ieee.exponent > v.ieee.exponent)
+ {
+ if (u.ieee.exponent > DBL_MANT_DIG)
+ u.ieee.exponent -= DBL_MANT_DIG;
+ }
+ else if (v.ieee.exponent > DBL_MANT_DIG)
+ v.ieee.exponent -= DBL_MANT_DIG;
+ w.ieee.exponent -= DBL_MANT_DIG;
+ adjust = 1;
+ }
+ else if (u.ieee.exponent >= 0x7ff - DBL_MANT_DIG)
+ {
+ u.ieee.exponent -= DBL_MANT_DIG;
+ v.ieee.exponent += DBL_MANT_DIG;
+ }
+ else
+ {
+ v.ieee.exponent -= DBL_MANT_DIG;
+ u.ieee.exponent += DBL_MANT_DIG;
+ }
+ x = u.d;
+ y = v.d;
+ z = w.d;
+ }
+ /* Multiplication m1 + m2 = x * y using Dekker's algorithm. */
+#define C ((1 << (DBL_MANT_DIG + 1) / 2) + 1)
+ double x1 = x * C;
+ double y1 = y * C;
+ double m1 = x * y;
+ x1 = (x - x1) + x1;
+ y1 = (y - y1) + y1;
+ double x2 = x - x1;
+ double y2 = y - y1;
+ double m2 = (((x1 * y1 - m1) + x1 * y2) + x2 * y1) + x2 * y2;
+
+ /* Addition a1 + a2 = z + m1 using Knuth's algorithm. */
+ double a1 = z + m1;
+ double t1 = a1 - z;
+ double t2 = a1 - t1;
+ t1 = m1 - t1;
+ t2 = z - t2;
+ double a2 = t1 + t2;
+
+ fenv_t env;
+ feholdexcept (&env);
+ fesetround (FE_TOWARDZERO);
+ /* Perform m2 + a2 addition with round to odd. */
+ u.d = a2 + m2;
+ if ((u.ieee.mantissa1 & 1) == 0 && u.ieee.exponent != 0x7ff)
+ u.ieee.mantissa1 |= fetestexcept (FE_INEXACT) != 0;
+ feupdateenv (&env);
+
+ /* Add that to a1. */
+ a1 = a1 + u.d;
+
+ /* And adjust exponent if needed. */
+ if (__builtin_expect (adjust, 0))
+ a1 *= 0x1p53;
+
+ return a1;
+}
+#ifndef __fma
+weak_alias (__fma, fma)
+#endif
+
+#ifdef NO_LONG_DOUBLE
+strong_alias (__fma, __fmal)
+weak_alias (__fmal, fmal)
+#endif
--- libc/sysdeps/i386/i686/multiarch/s_fma.c.jj 2010-05-03 20:18:36.000000000 +0200
+++ libc/sysdeps/i386/i686/multiarch/s_fma.c 2010-10-12 20:38:24.000000000 +0200
@@ -33,4 +33,4 @@ weak_alias (__fma, fma)
# define __fma __fma_ia32
#endif
-#include <math/s_fma.c>
+#include <sysdeps/ieee754/dbl-64/s_fma.c>
--- libc/sysdeps/x86_64/multiarch/s_fma.c.jj 2009-09-03 12:12:45.000000000 +0200
+++ libc/sysdeps/x86_64/multiarch/s_fma.c 2010-10-12 17:36:18.000000000 +0200
@@ -1,5 +1,5 @@
/* FMA version of fma.
- Copyright (C) 2009 Free Software Foundation, Inc.
+ Copyright (C) 2009, 2010 Free Software Foundation, Inc.
Contributed by Intel Corporation.
This file is part of the GNU C Library.
@@ -40,4 +40,4 @@ weak_alias (__fma, fma)
# define __fma __fma_sse2
#endif
-#include <math/s_fma.c>
+#include <sysdeps/ieee754/dbl-64/s_fma.c>
--- libc/sysdeps/ieee754/ldbl-opt/s_fma.c.jj 2009-05-16 19:23:39.000000000 +0200
+++ libc/sysdeps/ieee754/ldbl-opt/s_fma.c 2010-10-12 20:39:13.000000000 +0200
@@ -1,5 +1,5 @@
#include <math_ldbl_opt.h>
-#include <math/s_fma.c>
+#include <sysdeps/ieee754/dbl-64/s_fma.c>
#if LONG_DOUBLE_COMPAT(libm, GLIBC_2_1)
compat_symbol (libm, __fma, fmal, GLIBC_2_1);
#endif
--- libc/sysdeps/ieee754/ldbl-128/s_fma.c.jj 2010-10-12 20:40:47.000000000 +0200
+++ libc/sysdeps/ieee754/ldbl-128/s_fma.c 2010-10-12 20:43:51.000000000 +0200
@@ -0,0 +1,50 @@
+/* Compute x * y + z as ternary operation.
+ Copyright (C) 2010 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Jakub Jelinek <jakub@redhat.com>, 2010.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#include <math.h>
+#include <fenv.h>
+#include <ieee754.h>
+
+/* This implementation relies on long double being more than twice as
+ precise as double and uses rounding to odd in order to avoid problems
+ with double rounding.
+ See a paper by Boldo and Melquiond:
+ http://www.lri.fr/~melquion/doc/08-tc.pdf */
+
+double
+__fma (double x, double y, double z)
+{
+ fenv_t env;
+ /* Multiplication is always exact. */
+ long double temp = (long double) x * (long double) y;
+ union ieee854_long_double u;
+ feholdexcept (&env);
+ fesetround (FE_TOWARDZERO);
+ /* Perform addition with round to odd. */
+ u.d = temp + (long double) z;
+ if ((u.ieee.mantissa3 & 1) == 0 && u.ieee.exponent != 0x7fff)
+ u.ieee.mantissa3 |= fetestexcept (FE_INEXACT) != 0;
+ feupdateenv (&env);
+ /* And finally truncation with round to nearest. */
+ return (double) u.d;
+}
+#ifndef __fma
+weak_alias (__fma, fma)
+#endif
Jakub