AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-11-21 12:30:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

Optimize s_modf

Browse Source
This commit is contained in:
Ulrich Drepper 2012-01-10 22:26:22 -05:00
parent e58ef0f204
commit daa891c0e8
6 changed files with 88 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ChangeLog
View File

@ -1,5 +1,11 @@
2012-01-10 Ulrich Drepper <drepper@gmail.com>
* sysdeps/ieee754/dbl-64/wordsize-64/s_modf.c: New file.
* sysdeps/ieee754/dbl-64/s_modf.c: Add branch prediction.
* sysdeps/ieee754/flt-32/s_modff.c: Likewise.
* sysdeps/ieee754/ldbl-96/s_modfl.c: Likewise.
* math/bits/mathcalls.h: Add const attribute to fmin and fmax.
* sysdeps/ieee754/dbl-64/s_scalbn.c: Add branch prediction.

5
NEWS
View File

@ -1,4 +1,4 @@
GNU C Library NEWS -- history of user-visible changes. 2012-1-8
GNU C Library NEWS -- history of user-visible changes. 2012-1-10
Copyright (C) 1992-2009, 2010, 2011, 2012 Free Software Foundation, Inc.
See the end for copying conditions.
@ -39,6 +39,9 @@ Version 2.16
* Checking versions of poll, ppoll added.
Implemented by Ulrich Drepper.
* More generic and 64-bit performance optimizations to math functions.
Implemented by Ulrich Drepper.
Version 2.15

23
sysdeps/ieee754/dbl-64/s_modf.c
View File

@ -1,4 +1,3 @@
/* @(#)s_modf.c 5.1 93/09/24 */
/*
* ====================================================
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
@ -10,10 +9,6 @@
* ====================================================
*/
#if defined(LIBM_SCCS) && !defined(lint)
static char rcsid[] = "$NetBSD: s_modf.c,v 1.8 1995/05/10 20:47:55 jtc Exp $";
#endif
/*
* modf(double x, double *iptr)
* return fraction part of x, and return x's integral part in *iptr.
@ -27,18 +22,10 @@ static char rcsid[] = "$NetBSD: s_modf.c,v 1.8 1995/05/10 20:47:55 jtc Exp $";
#include "math.h"
#include "math_private.h"
#ifdef __STDC__
static const double one = 1.0;
#else
static double one = 1.0;
#endif
#ifdef __STDC__
double __modf(double x, double *iptr)
#else
double __modf(x, iptr)
double x,*iptr;
#endif
double
__modf(double x, double *iptr)
{
int32_t i0,i1,j0;
u_int32_t i;
@ -46,7 +33,7 @@ static double one = 1.0;
j0 = ((i0>>20)&0x7ff)-0x3ff; /* exponent of x */
if(j0<20) { /* integer part in high x */
if(j0<0) { /* |x|<1 */
INSERT_WORDS(*iptr,i0&0x80000000,0); /* *iptr = +-0 */
INSERT_WORDS(*iptr,i0&0x80000000,0); /* *iptr = +-0 */
return x;
} else {
i = (0x000fffff)>>j0;
@ -59,7 +46,7 @@ static double one = 1.0;
return x - *iptr;
}
}
} else if (j0>51) { /* no fraction part */
} else if (__builtin_expect(j0>51, 0)) { /* no fraction part */
*iptr = x*one;
/* We must handle NaNs separately. */
if (j0 == 0x400 && ((i0 & 0xfffff) | i1))
@ -73,7 +60,7 @@ static double one = 1.0;
INSERT_WORDS(x,i0&0x80000000,0); /* return +-0 */
return x;
} else {
INSERT_WORDS(*iptr,i0,i1&(~i));
INSERT_WORDS(*iptr,i0,i1&(~i));
return x - *iptr;
}
}

65
sysdeps/ieee754/dbl-64/wordsize-64/s_modf.c Normal file
View File

@ -0,0 +1,65 @@
/* Rewritten for 64-bit machines by Ulrich Drepper <drepper@gmail.com>. */
/*
* ====================================================
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
*
* Developed at SunPro, a Sun Microsystems, Inc. business.
* Permission to use, copy, modify, and distribute this
* software is freely granted, provided that this notice
* is preserved.
* ====================================================
*/
/*
* modf(double x, double *iptr)
* return fraction part of x, and return x's integral part in *iptr.
* Method:
* Bit twiddling.
*
* Exception:
* No exception.
*/
#include "math.h"
#include "math_private.h"
static const double one = 1.0;
double
__modf(double x, double *iptr)
{
int64_t i0;
int32_t j0;
EXTRACT_WORDS64(i0,x);
j0 = ((i0>>52)&0x7ff)-0x3ff; /* exponent of x */
if(j0<52) { /* integer part in x */
if(j0<0) { /* |x|<1 */
/* *iptr = +-0 */
INSERT_WORDS64(*iptr,i0&UINT64_C(0x8000000000000000));
return x;
} else {
uint64_t i = UINT64_C(0x000fffffffffffff)>>j0;
if((i0&i)==0) { /* x is integral */
*iptr = x;
/* return +-0 */
INSERT_WORDS64(x,i0&UINT64_C(0x8000000000000000));
return x;
} else {
INSERT_WORDS64(*iptr,i0&(~i));
return x - *iptr;
}
}
} else { /* no fraction part */
*iptr = x*one;
/* We must handle NaNs separately. */
if (j0 == 0x400 && (i0 & UINT64_C(0xfffffffffffff)))
return x*one;
INSERT_WORDS64(x,i0&UINT64_C(0x8000000000000000)); /* return +-0 */
return x;
}
}
weak_alias (__modf, modf)
#ifdef NO_LONG_DOUBLE
strong_alias (__modf, __modfl)
weak_alias (__modf, modfl)
#endif

20
sysdeps/ieee754/flt-32/s_modff.c
View File

@ -13,33 +13,21 @@
* ====================================================
*/
#if defined(LIBM_SCCS) && !defined(lint)
static char rcsid[] = "$NetBSD: s_modff.c,v 1.4 1995/05/10 20:47:56 jtc Exp $";
#endif
#include "math.h"
#include "math_private.h"
#ifdef __STDC__
static const float one = 1.0;
#else
static float one = 1.0;
#endif
#ifdef __STDC__
float __modff(float x, float *iptr)
#else
float __modff(x, iptr)
float x,*iptr;
#endif
float
__modff(float x, float *iptr)
{
int32_t i0,j0;
u_int32_t i;
GET_FLOAT_WORD(i0,x);
j0 = ((i0>>23)&0xff)-0x7f; /* exponent of x */
if(j0<23) { /* integer part in x */
if(__builtin_expect(j0<23, 1)) { /* integer part in x */
if(j0<0) { /* |x|<1 */
SET_FLOAT_WORD(*iptr,i0&0x80000000); /* *iptr = +-0 */
SET_FLOAT_WORD(*iptr,i0&0x80000000); /* *iptr = +-0 */
return x;
} else {
i = (0x007fffff)>>j0;

20
sysdeps/ieee754/ldbl-96/s_modfl.c
View File

@ -14,10 +14,6 @@
* ====================================================
*/
#if defined(LIBM_SCCS) && !defined(lint)
static char rcsid[] = "$NetBSD: $";
#endif
/*
* modfl(long double x, long double *iptr)
* return fraction part of x, and return x's integral part in *iptr.
@ -31,18 +27,10 @@ static char rcsid[] = "$NetBSD: $";
#include "math.h"
#include "math_private.h"
#ifdef __STDC__
static const long double one = 1.0;
#else
static long double one = 1.0;
#endif
#ifdef __STDC__
long double __modfl(long double x, long double *iptr)
#else
long double __modfl(x, iptr)
long double x,*iptr;
#endif
long double
__modfl(long double x, long double *iptr)
{
int32_t i0,i1,j0;
u_int32_t i,se;
@ -50,7 +38,7 @@ static long double one = 1.0;
j0 = (se&0x7fff)-0x3fff; /* exponent of x */
if(j0<32) { /* integer part in high x */
if(j0<0) { /* |x|<1 */
SET_LDOUBLE_WORDS(*iptr,se&0x8000,0,0); /* *iptr = +-0 */
SET_LDOUBLE_WORDS(*iptr,se&0x8000,0,0); /* *iptr = +-0 */
return x;
} else {
i = (0x7fffffff)>>j0;
@ -63,7 +51,7 @@ static long double one = 1.0;
return x - *iptr;
}
}
} else if (j0>63) { /* no fraction part */
} else if (__builtin_expect(j0>63, 0)) { /* no fraction part */
*iptr = x*one;
/* We must handle NaNs separately. */
if (j0 == 0x4000 && ((i0 & 0x7fffffff) | i1))