[v4,2/4] aarch64: Add vector implementations of sin routines
Checks
Context |
Check |
Description |
redhat-pt-bot/TryBot-apply_patch |
success
|
Patch applied to master at the time it was sent
|
linaro-tcwg-bot/tcwg_glibc_check--master-aarch64 |
warning
|
Patch failed to apply
|
linaro-tcwg-bot/tcwg_glibc_build--master-aarch64 |
warning
|
Patch failed to apply
|
linaro-tcwg-bot/tcwg_glibc_check--master-arm |
warning
|
Patch failed to apply
|
linaro-tcwg-bot/tcwg_glibc_build--master-arm |
warning
|
Patch failed to apply
|
Commit Message
Optimised implementations for single and double precision, Advanced
SIMD and SVE, copied from Arm Optimized Routines.
As previously, data tables are used via a barrier to prevent
overly aggressive constant inlining. Special-case handlers are
marked NOINLINE to avoid incurring the penalty of switching call
standards unnecessarily.
---
Changes to v3:
* Remove volatile from AdvSIMD data - use ptr_barrier instead
Thanks,
Joe
sysdeps/aarch64/fpu/Makefile | 12 +-
sysdeps/aarch64/fpu/Versions | 4 +
sysdeps/aarch64/fpu/bits/math-vector.h | 6 +
sysdeps/aarch64/fpu/sin_advsimd.c | 106 ++++++++++++++++++
sysdeps/aarch64/fpu/sin_sve.c | 97 ++++++++++++++++
sysdeps/aarch64/fpu/sinf_advsimd.c | 99 ++++++++++++++++
sysdeps/aarch64/fpu/sinf_sve.c | 96 ++++++++++++++++
.../fpu/test-double-advsimd-wrappers.c | 1 +
.../aarch64/fpu/test-double-sve-wrappers.c | 1 +
.../aarch64/fpu/test-float-advsimd-wrappers.c | 1 +
sysdeps/aarch64/fpu/test-float-sve-wrappers.c | 1 +
sysdeps/aarch64/libm-test-ulps | 8 ++
.../unix/sysv/linux/aarch64/libmvec.abilist | 4 +
13 files changed, 430 insertions(+), 6 deletions(-)
create mode 100644 sysdeps/aarch64/fpu/sin_advsimd.c
create mode 100644 sysdeps/aarch64/fpu/sin_sve.c
create mode 100644 sysdeps/aarch64/fpu/sinf_advsimd.c
create mode 100644 sysdeps/aarch64/fpu/sinf_sve.c
Comments
The 06/28/2023 12:19, Joe Ramsay via Libc-alpha wrote:
> Optimised implementations for single and double precision, Advanced
> SIMD and SVE, copied from Arm Optimized Routines.
>
> As previously, data tables are used via a barrier to prevent
> overly aggressive constant inlining. Special-case handlers are
> marked NOINLINE to avoid incurring the penalty of switching call
> standards unnecessarily.
Reviewed-by: Szabolcs Nagy <szabolcs.nagy@arm.com>
> ---
> Changes to v3:
> * Remove volatile from AdvSIMD data - use ptr_barrier instead
> Thanks,
> Joe
> sysdeps/aarch64/fpu/Makefile | 12 +-
> sysdeps/aarch64/fpu/Versions | 4 +
> sysdeps/aarch64/fpu/bits/math-vector.h | 6 +
> sysdeps/aarch64/fpu/sin_advsimd.c | 106 ++++++++++++++++++
> sysdeps/aarch64/fpu/sin_sve.c | 97 ++++++++++++++++
> sysdeps/aarch64/fpu/sinf_advsimd.c | 99 ++++++++++++++++
> sysdeps/aarch64/fpu/sinf_sve.c | 96 ++++++++++++++++
> .../fpu/test-double-advsimd-wrappers.c | 1 +
> .../aarch64/fpu/test-double-sve-wrappers.c | 1 +
> .../aarch64/fpu/test-float-advsimd-wrappers.c | 1 +
> sysdeps/aarch64/fpu/test-float-sve-wrappers.c | 1 +
> sysdeps/aarch64/libm-test-ulps | 8 ++
> .../unix/sysv/linux/aarch64/libmvec.abilist | 4 +
> 13 files changed, 430 insertions(+), 6 deletions(-)
> create mode 100644 sysdeps/aarch64/fpu/sin_advsimd.c
> create mode 100644 sysdeps/aarch64/fpu/sin_sve.c
> create mode 100644 sysdeps/aarch64/fpu/sinf_advsimd.c
> create mode 100644 sysdeps/aarch64/fpu/sinf_sve.c
>
> diff --git a/sysdeps/aarch64/fpu/Makefile b/sysdeps/aarch64/fpu/Makefile
> index 850cfb9012..9ceea35148 100644
> --- a/sysdeps/aarch64/fpu/Makefile
> +++ b/sysdeps/aarch64/fpu/Makefile
> @@ -1,10 +1,10 @@
> -float-advsimd-funcs = cos
> +libmvec-supported-funcs = cos \
> + sin
>
> -double-advsimd-funcs = cos
> -
> -float-sve-funcs = cos
> -
> -double-sve-funcs = cos
> +float-advsimd-funcs = $(libmvec-supported-funcs)
> +double-advsimd-funcs = $(libmvec-supported-funcs)
> +float-sve-funcs = $(libmvec-supported-funcs)
> +double-sve-funcs = $(libmvec-supported-funcs)
>
> ifeq ($(subdir),mathvec)
> libmvec-support = $(addsuffix f_advsimd,$(float-advsimd-funcs)) \
> diff --git a/sysdeps/aarch64/fpu/Versions b/sysdeps/aarch64/fpu/Versions
> index 5222a6f180..d26b3968a9 100644
> --- a/sysdeps/aarch64/fpu/Versions
> +++ b/sysdeps/aarch64/fpu/Versions
> @@ -1,8 +1,12 @@
> libmvec {
> GLIBC_2.38 {
> _ZGVnN2v_cos;
> + _ZGVnN2v_sin;
> _ZGVnN4v_cosf;
> + _ZGVnN4v_sinf;
> _ZGVsMxv_cos;
> _ZGVsMxv_cosf;
> + _ZGVsMxv_sin;
> + _ZGVsMxv_sinf;
> }
> }
> diff --git a/sysdeps/aarch64/fpu/bits/math-vector.h b/sysdeps/aarch64/fpu/bits/math-vector.h
> index a2f2277591..ad9c9945e8 100644
> --- a/sysdeps/aarch64/fpu/bits/math-vector.h
> +++ b/sysdeps/aarch64/fpu/bits/math-vector.h
> @@ -50,7 +50,10 @@ typedef __SVBool_t __sv_bool_t;
> # define __vpcs __attribute__ ((__aarch64_vector_pcs__))
>
> __vpcs __f32x4_t _ZGVnN4v_cosf (__f32x4_t);
> +__vpcs __f32x4_t _ZGVnN4v_sinf (__f32x4_t);
> +
> __vpcs __f64x2_t _ZGVnN2v_cos (__f64x2_t);
> +__vpcs __f64x2_t _ZGVnN2v_sin (__f64x2_t);
>
> # undef __ADVSIMD_VEC_MATH_SUPPORTED
> #endif /* __ADVSIMD_VEC_MATH_SUPPORTED */
> @@ -58,7 +61,10 @@ __vpcs __f64x2_t _ZGVnN2v_cos (__f64x2_t);
> #ifdef __SVE_VEC_MATH_SUPPORTED
>
> __sv_f32_t _ZGVsMxv_cosf (__sv_f32_t, __sv_bool_t);
> +__sv_f32_t _ZGVsMxv_sinf (__sv_f32_t, __sv_bool_t);
> +
> __sv_f64_t _ZGVsMxv_cos (__sv_f64_t, __sv_bool_t);
> +__sv_f64_t _ZGVsMxv_sin (__sv_f64_t, __sv_bool_t);
>
> # undef __SVE_VEC_MATH_SUPPORTED
> #endif /* __SVE_VEC_MATH_SUPPORTED */
> diff --git a/sysdeps/aarch64/fpu/sin_advsimd.c b/sysdeps/aarch64/fpu/sin_advsimd.c
> new file mode 100644
> index 0000000000..ddc4142599
> --- /dev/null
> +++ b/sysdeps/aarch64/fpu/sin_advsimd.c
> @@ -0,0 +1,106 @@
> +/* Double-precision vector (Advanced SIMD) sin function.
> +
> + Copyright (C) 2023 Free Software Foundation, Inc.
> + This file is part of the GNU C Library.
> +
> + 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, see
> + <https://www.gnu.org/licenses/>. */
> +
> +#include "v_math.h"
> +
> +static const struct data
> +{
> + float64x2_t poly[7];
> + float64x2_t range_val, inv_pi, shift, pi_1, pi_2, pi_3;
> +} data = {
> + /* Worst-case error is 2.8 ulp in [-pi/2, pi/2]. */
> + .poly = { V2 (-0x1.555555555547bp-3), V2 (0x1.1111111108a4dp-7),
> + V2 (-0x1.a01a019936f27p-13), V2 (0x1.71de37a97d93ep-19),
> + V2 (-0x1.ae633919987c6p-26), V2 (0x1.60e277ae07cecp-33),
> + V2 (-0x1.9e9540300a1p-41) },
> +
> + .range_val = V2 (0x1p23),
> + .inv_pi = V2 (0x1.45f306dc9c883p-2),
> + .pi_1 = V2 (0x1.921fb54442d18p+1),
> + .pi_2 = V2 (0x1.1a62633145c06p-53),
> + .pi_3 = V2 (0x1.c1cd129024e09p-106),
> + .shift = V2 (0x1.8p52),
> +};
> +
> +#if WANT_SIMD_EXCEPT
> +# define TinyBound v_u64 (0x3000000000000000) /* asuint64 (0x1p-255). */
> +# define Thresh v_u64 (0x1160000000000000) /* RangeVal - TinyBound. */
> +#endif
> +
> +#define C(i) d->poly[i]
> +
> +static float64x2_t VPCS_ATTR NOINLINE
> +special_case (float64x2_t x, float64x2_t y, uint64x2_t odd, uint64x2_t cmp)
> +{
> + y = vreinterpretq_f64_u64 (veorq_u64 (vreinterpretq_u64_f64 (y), odd));
> + return v_call_f64 (sin, x, y, cmp);
> +}
> +
> +float64x2_t VPCS_ATTR V_NAME_D1 (sin) (float64x2_t x)
> +{
> + const struct data *d = ptr_barrier (&data);
> + float64x2_t n, r, r2, r3, r4, y, t1, t2, t3;
> + uint64x2_t odd, cmp, eqz;
> +
> +#if WANT_SIMD_EXCEPT
> + /* Detect |x| <= TinyBound or |x| >= RangeVal. If fenv exceptions are to be
> + triggered correctly, set any special lanes to 1 (which is neutral w.r.t.
> + fenv). These lanes will be fixed by special-case handler later. */
> + uint64x2_t ir = vreinterpretq_u64_f64 (vabsq_f64 (x));
> + cmp = vcgeq_u64 (vsubq_u64 (ir, TinyBound), Thresh);
> + r = vbslq_f64 (cmp, vreinterpretq_f64_u64 (cmp), x);
> +#else
> + r = x;
> + cmp = vcageq_f64 (d->range_val, x);
> + cmp = vceqzq_u64 (cmp); /* cmp = ~cmp. */
> +#endif
> + eqz = vceqzq_f64 (x);
> +
> + /* n = rint(|x|/pi). */
> + n = vfmaq_f64 (d->shift, d->inv_pi, r);
> + odd = vshlq_n_u64 (vreinterpretq_u64_f64 (n), 63);
> + n = vsubq_f64 (n, d->shift);
> +
> + /* r = |x| - n*pi (range reduction into -pi/2 .. pi/2). */
> + r = vfmsq_f64 (r, d->pi_1, n);
> + r = vfmsq_f64 (r, d->pi_2, n);
> + r = vfmsq_f64 (r, d->pi_3, n);
> +
> + /* sin(r) poly approx. */
> + r2 = vmulq_f64 (r, r);
> + r3 = vmulq_f64 (r2, r);
> + r4 = vmulq_f64 (r2, r2);
> +
> + t1 = vfmaq_f64 (C (4), C (5), r2);
> + t2 = vfmaq_f64 (C (2), C (3), r2);
> + t3 = vfmaq_f64 (C (0), C (1), r2);
> +
> + y = vfmaq_f64 (t1, C (6), r4);
> + y = vfmaq_f64 (t2, y, r4);
> + y = vfmaq_f64 (t3, y, r4);
> + y = vfmaq_f64 (r, y, r3);
> +
> + /* Sign of 0 is discarded by polynomial, so copy it back here. */
> + if (__glibc_unlikely (v_any_u64 (eqz)))
> + y = vbslq_f64 (eqz, x, y);
> +
> + if (__glibc_unlikely (v_any_u64 (cmp)))
> + return special_case (x, y, odd, cmp);
> + return vreinterpretq_f64_u64 (veorq_u64 (vreinterpretq_u64_f64 (y), odd));
> +}
> diff --git a/sysdeps/aarch64/fpu/sin_sve.c b/sysdeps/aarch64/fpu/sin_sve.c
> new file mode 100644
> index 0000000000..c3f450d0ea
> --- /dev/null
> +++ b/sysdeps/aarch64/fpu/sin_sve.c
> @@ -0,0 +1,97 @@
> +/* Double-precision vector (SVE) sin function.
> +
> + Copyright (C) 2023 Free Software Foundation, Inc.
> + This file is part of the GNU C Library.
> +
> + 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, see
> + <https://www.gnu.org/licenses/>. */
> +
> +#include "sv_math.h"
> +
> +static const struct data
> +{
> + double inv_pi, half_pi, inv_pi_over_2, pi_over_2_1, pi_over_2_2, pi_over_2_3,
> + shift;
> +} data = {
> + /* Polynomial coefficients are hard-wired in the FTMAD instruction. */
> + .inv_pi = 0x1.45f306dc9c883p-2,
> + .half_pi = 0x1.921fb54442d18p+0,
> + .inv_pi_over_2 = 0x1.45f306dc9c882p-1,
> + .pi_over_2_1 = 0x1.921fb50000000p+0,
> + .pi_over_2_2 = 0x1.110b460000000p-26,
> + .pi_over_2_3 = 0x1.1a62633145c07p-54,
> + .shift = 0x1.8p52
> +};
> +
> +#define RangeVal 0x4160000000000000 /* asuint64 (0x1p23). */
> +
> +static svfloat64_t NOINLINE
> +special_case (svfloat64_t x, svfloat64_t y, svbool_t cmp)
> +{
> + return sv_call_f64 (sin, x, y, cmp);
> +}
> +
> +/* A fast SVE implementation of sin based on trigonometric
> + instructions (FTMAD, FTSSEL, FTSMUL).
> + Maximum observed error in 2.52 ULP:
> + SV_NAME_D1 (sin)(0x1.2d2b00df69661p+19) got 0x1.10ace8f3e786bp-40
> + want 0x1.10ace8f3e7868p-40. */
> +svfloat64_t SV_NAME_D1 (sin) (svfloat64_t x, const svbool_t pg)
> +{
> + const struct data *d = ptr_barrier (&data);
> +
> + svfloat64_t r = svabs_f64_x (pg, x);
> + svuint64_t sign
> + = sveor_u64_x (pg, svreinterpret_u64_f64 (x), svreinterpret_u64_f64 (r));
> + svbool_t cmp = svcmpge_n_u64 (pg, svreinterpret_u64_f64 (r), RangeVal);
> +
> + /* Load first two pio2-related constants to one vector. */
> + svfloat64_t invpio2_and_pio2_1
> + = svld1rq_f64 (svptrue_b64 (), &d->inv_pi_over_2);
> +
> + /* n = rint(|x|/(pi/2)). */
> + svfloat64_t q = svmla_lane_f64 (sv_f64 (d->shift), r, invpio2_and_pio2_1, 0);
> + svfloat64_t n = svsub_n_f64_x (pg, q, d->shift);
> +
> + /* r = |x| - n*(pi/2) (range reduction into -pi/4 .. pi/4). */
> + r = svmls_lane_f64 (r, n, invpio2_and_pio2_1, 1);
> + r = svmls_n_f64_x (pg, r, n, d->pi_over_2_2);
> + r = svmls_n_f64_x (pg, r, n, d->pi_over_2_3);
> +
> + /* Final multiplicative factor: 1.0 or x depending on bit #0 of q. */
> + svfloat64_t f = svtssel_f64 (r, svreinterpret_u64_f64 (q));
> +
> + /* sin(r) poly approx. */
> + svfloat64_t r2 = svtsmul_f64 (r, svreinterpret_u64_f64 (q));
> + svfloat64_t y = sv_f64 (0.0);
> + y = svtmad_f64 (y, r2, 7);
> + y = svtmad_f64 (y, r2, 6);
> + y = svtmad_f64 (y, r2, 5);
> + y = svtmad_f64 (y, r2, 4);
> + y = svtmad_f64 (y, r2, 3);
> + y = svtmad_f64 (y, r2, 2);
> + y = svtmad_f64 (y, r2, 1);
> + y = svtmad_f64 (y, r2, 0);
> +
> + /* Apply factor. */
> + y = svmul_f64_x (pg, f, y);
> +
> + /* sign = y^sign. */
> + y = svreinterpret_f64_u64 (
> + sveor_u64_x (pg, svreinterpret_u64_f64 (y), sign));
> +
> + if (__glibc_unlikely (svptest_any (pg, cmp)))
> + return special_case (x, y, cmp);
> + return y;
> +}
> diff --git a/sysdeps/aarch64/fpu/sinf_advsimd.c b/sysdeps/aarch64/fpu/sinf_advsimd.c
> new file mode 100644
> index 0000000000..b67d37f2fd
> --- /dev/null
> +++ b/sysdeps/aarch64/fpu/sinf_advsimd.c
> @@ -0,0 +1,99 @@
> +/* Single-precision vector (Advanced SIMD) sin function.
> +
> + Copyright (C) 2023 Free Software Foundation, Inc.
> + This file is part of the GNU C Library.
> +
> + 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, see
> + <https://www.gnu.org/licenses/>. */
> +
> +#include "v_math.h"
> +
> +static const struct data
> +{
> + float32x4_t poly[4];
> + float32x4_t range_val, inv_pi, shift, pi_1, pi_2, pi_3;
> +} data = {
> + /* 1.886 ulp error. */
> + .poly = { V4 (-0x1.555548p-3f), V4 (0x1.110df4p-7f), V4 (-0x1.9f42eap-13f),
> + V4 (0x1.5b2e76p-19f) },
> +
> + .pi_1 = V4 (0x1.921fb6p+1f),
> + .pi_2 = V4 (-0x1.777a5cp-24f),
> + .pi_3 = V4 (-0x1.ee59dap-49f),
> +
> + .inv_pi = V4 (0x1.45f306p-2f),
> + .shift = V4 (0x1.8p+23f),
> + .range_val = V4 (0x1p20f)
> +};
> +
> +#if WANT_SIMD_EXCEPT
> +# define TinyBound v_u32 (0x21000000) /* asuint32(0x1p-61f). */
> +# define Thresh v_u32 (0x28800000) /* RangeVal - TinyBound. */
> +#endif
> +
> +#define C(i) d->poly[i]
> +
> +static float32x4_t VPCS_ATTR NOINLINE
> +special_case (float32x4_t x, float32x4_t y, uint32x4_t odd, uint32x4_t cmp)
> +{
> + /* Fall back to scalar code. */
> + y = vreinterpretq_f32_u32 (veorq_u32 (vreinterpretq_u32_f32 (y), odd));
> + return v_call_f32 (sinf, x, y, cmp);
> +}
> +
> +float32x4_t VPCS_ATTR V_NAME_F1 (sin) (float32x4_t x)
> +{
> + const struct data *d = ptr_barrier (&data);
> + float32x4_t n, r, r2, y;
> + uint32x4_t odd, cmp, eqz;
> +
> +#if WANT_SIMD_EXCEPT
> + uint32x4_t ir = vreinterpretq_u32_f32 (vabsq_f32 (x));
> + cmp = vcgeq_u32 (vsubq_u32 (ir, TinyBound), Thresh);
> + /* If fenv exceptions are to be triggered correctly, set any special lanes
> + to 1 (which is neutral w.r.t. fenv). These lanes will be fixed by
> + special-case handler later. */
> + r = vbslq_f32 (cmp, vreinterpretq_f32_u32 (cmp), x);
> +#else
> + r = x;
> + cmp = vcageq_f32 (d->range_val, x);
> + cmp = vceqzq_u32 (cmp); /* cmp = ~cmp. */
> +#endif
> + eqz = vceqzq_f32 (x);
> +
> + /* n = rint(|x|/pi) */
> + n = vfmaq_f32 (d->shift, d->inv_pi, r);
> + odd = vshlq_n_u32 (vreinterpretq_u32_f32 (n), 31);
> + n = vsubq_f32 (n, d->shift);
> +
> + /* r = |x| - n*pi (range reduction into -pi/2 .. pi/2) */
> + r = vfmsq_f32 (r, d->pi_1, n);
> + r = vfmsq_f32 (r, d->pi_2, n);
> + r = vfmsq_f32 (r, d->pi_3, n);
> +
> + /* y = sin(r) */
> + r2 = vmulq_f32 (r, r);
> + y = vfmaq_f32 (C (2), C (3), r2);
> + y = vfmaq_f32 (C (1), y, r2);
> + y = vfmaq_f32 (C (0), y, r2);
> + y = vfmaq_f32 (r, vmulq_f32 (y, r2), r);
> +
> + /* Sign of 0 is discarded by polynomial, so copy it back here. */
> + if (__glibc_unlikely (v_any_u32 (eqz)))
> + y = vbslq_f32 (eqz, x, y);
> +
> + if (__glibc_unlikely (v_any_u32 (cmp)))
> + return special_case (x, y, odd, cmp);
> + return vreinterpretq_f32_u32 (veorq_u32 (vreinterpretq_u32_f32 (y), odd));
> +}
> diff --git a/sysdeps/aarch64/fpu/sinf_sve.c b/sysdeps/aarch64/fpu/sinf_sve.c
> new file mode 100644
> index 0000000000..4d2ce7a846
> --- /dev/null
> +++ b/sysdeps/aarch64/fpu/sinf_sve.c
> @@ -0,0 +1,96 @@
> +/* Single-precision vector (SVE) sin function.
> +
> + Copyright (C) 2023 Free Software Foundation, Inc.
> + This file is part of the GNU C Library.
> +
> + 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, see
> + <https://www.gnu.org/licenses/>. */
> +
> +#include "sv_math.h"
> +
> +static const struct data
> +{
> + float poly[4];
> + /* Pi-related values to be loaded as one quad-word and used with
> + svmla_lane_f32. */
> + float negpi1, negpi2, negpi3, invpi;
> + float shift;
> +} data = {
> + .poly = {
> + /* Non-zero coefficients from the degree 9 Taylor series expansion of
> + sin. */
> + -0x1.555548p-3f, 0x1.110df4p-7f, -0x1.9f42eap-13f, 0x1.5b2e76p-19f
> + },
> + .negpi1 = -0x1.921fb6p+1f,
> + .negpi2 = 0x1.777a5cp-24f,
> + .negpi3 = 0x1.ee59dap-49f,
> + .invpi = 0x1.45f306p-2f,
> + .shift = 0x1.8p+23f
> +};
> +
> +#define RangeVal 0x49800000 /* asuint32 (0x1p20f). */
> +#define C(i) sv_f32 (d->poly[i])
> +
> +static svfloat32_t NOINLINE
> +special_case (svfloat32_t x, svfloat32_t y, svbool_t cmp)
> +{
> + return sv_call_f32 (sinf, x, y, cmp);
> +}
> +
> +/* A fast SVE implementation of sinf.
> + Maximum error: 1.89 ULPs.
> + This maximum error is achieved at multiple values in [-2^18, 2^18]
> + but one example is:
> + SV_NAME_F1 (sin)(0x1.9247a4p+0) got 0x1.fffff6p-1 want 0x1.fffffap-1. */
> +svfloat32_t SV_NAME_F1 (sin) (svfloat32_t x, const svbool_t pg)
> +{
> + const struct data *d = ptr_barrier (&data);
> +
> + svfloat32_t ax = svabs_f32_x (pg, x);
> + svuint32_t sign = sveor_u32_x (pg, svreinterpret_u32_f32 (x),
> + svreinterpret_u32_f32 (ax));
> + svbool_t cmp = svcmpge_n_u32 (pg, svreinterpret_u32_f32 (ax), RangeVal);
> +
> + /* pi_vals are a quad-word of helper values - the first 3 elements contain
> + -pi in extended precision, the last contains 1 / pi. */
> + svfloat32_t pi_vals = svld1rq_f32 (svptrue_b32 (), &d->negpi1);
> +
> + /* n = rint(|x|/pi). */
> + svfloat32_t n = svmla_lane_f32 (sv_f32 (d->shift), ax, pi_vals, 3);
> + svuint32_t odd = svlsl_n_u32_x (pg, svreinterpret_u32_f32 (n), 31);
> + n = svsub_n_f32_x (pg, n, d->shift);
> +
> + /* r = |x| - n*pi (range reduction into -pi/2 .. pi/2). */
> + svfloat32_t r;
> + r = svmla_lane_f32 (ax, n, pi_vals, 0);
> + r = svmla_lane_f32 (r, n, pi_vals, 1);
> + r = svmla_lane_f32 (r, n, pi_vals, 2);
> +
> + /* sin(r) approx using a degree 9 polynomial from the Taylor series
> + expansion. Note that only the odd terms of this are non-zero. */
> + svfloat32_t r2 = svmul_f32_x (pg, r, r);
> + svfloat32_t y;
> + y = svmla_f32_x (pg, C (2), r2, C (3));
> + y = svmla_f32_x (pg, C (1), r2, y);
> + y = svmla_f32_x (pg, C (0), r2, y);
> + y = svmla_f32_x (pg, r, r, svmul_f32_x (pg, y, r2));
> +
> + /* sign = y^sign^odd. */
> + y = svreinterpret_f32_u32 (sveor_u32_x (pg, svreinterpret_u32_f32 (y),
> + sveor_u32_x (pg, sign, odd)));
> +
> + if (__glibc_unlikely (svptest_any (pg, cmp)))
> + return special_case (x, y, cmp);
> + return y;
> +}
> diff --git a/sysdeps/aarch64/fpu/test-double-advsimd-wrappers.c b/sysdeps/aarch64/fpu/test-double-advsimd-wrappers.c
> index cb45fd3298..4af97a25a2 100644
> --- a/sysdeps/aarch64/fpu/test-double-advsimd-wrappers.c
> +++ b/sysdeps/aarch64/fpu/test-double-advsimd-wrappers.c
> @@ -24,3 +24,4 @@
> #define VEC_TYPE float64x2_t
>
> VPCS_VECTOR_WRAPPER (cos_advsimd, _ZGVnN2v_cos)
> +VPCS_VECTOR_WRAPPER (sin_advsimd, _ZGVnN2v_sin)
> diff --git a/sysdeps/aarch64/fpu/test-double-sve-wrappers.c b/sysdeps/aarch64/fpu/test-double-sve-wrappers.c
> index cf72ef83b7..64c790adc5 100644
> --- a/sysdeps/aarch64/fpu/test-double-sve-wrappers.c
> +++ b/sysdeps/aarch64/fpu/test-double-sve-wrappers.c
> @@ -33,3 +33,4 @@
> }
>
> SVE_VECTOR_WRAPPER (cos_sve, _ZGVsMxv_cos)
> +SVE_VECTOR_WRAPPER (sin_sve, _ZGVsMxv_sin)
> diff --git a/sysdeps/aarch64/fpu/test-float-advsimd-wrappers.c b/sysdeps/aarch64/fpu/test-float-advsimd-wrappers.c
> index fa146862b0..50e776b952 100644
> --- a/sysdeps/aarch64/fpu/test-float-advsimd-wrappers.c
> +++ b/sysdeps/aarch64/fpu/test-float-advsimd-wrappers.c
> @@ -24,3 +24,4 @@
> #define VEC_TYPE float32x4_t
>
> VPCS_VECTOR_WRAPPER (cosf_advsimd, _ZGVnN4v_cosf)
> +VPCS_VECTOR_WRAPPER (sinf_advsimd, _ZGVnN4v_sinf)
> diff --git a/sysdeps/aarch64/fpu/test-float-sve-wrappers.c b/sysdeps/aarch64/fpu/test-float-sve-wrappers.c
> index bc26558c62..7355032929 100644
> --- a/sysdeps/aarch64/fpu/test-float-sve-wrappers.c
> +++ b/sysdeps/aarch64/fpu/test-float-sve-wrappers.c
> @@ -33,3 +33,4 @@
> }
>
> SVE_VECTOR_WRAPPER (cosf_sve, _ZGVsMxv_cosf)
> +SVE_VECTOR_WRAPPER (sinf_sve, _ZGVsMxv_sinf)
> diff --git a/sysdeps/aarch64/libm-test-ulps b/sysdeps/aarch64/libm-test-ulps
> index 07da4ab843..4145662b2d 100644
> --- a/sysdeps/aarch64/libm-test-ulps
> +++ b/sysdeps/aarch64/libm-test-ulps
> @@ -1257,11 +1257,19 @@ double: 1
> float: 1
> ldouble: 2
>
> +Function: "sin_advsimd":
> +double: 2
> +float: 1
> +
> Function: "sin_downward":
> double: 1
> float: 1
> ldouble: 3
>
> +Function: "sin_sve":
> +double: 2
> +float: 1
> +
> Function: "sin_towardzero":
> double: 1
> float: 1
> diff --git a/sysdeps/unix/sysv/linux/aarch64/libmvec.abilist b/sysdeps/unix/sysv/linux/aarch64/libmvec.abilist
> index 13af421af2..a4c564859c 100644
> --- a/sysdeps/unix/sysv/linux/aarch64/libmvec.abilist
> +++ b/sysdeps/unix/sysv/linux/aarch64/libmvec.abilist
> @@ -1,4 +1,8 @@
> GLIBC_2.38 _ZGVnN2v_cos F
> +GLIBC_2.38 _ZGVnN2v_sin F
> GLIBC_2.38 _ZGVnN4v_cosf F
> +GLIBC_2.38 _ZGVnN4v_sinf F
> GLIBC_2.38 _ZGVsMxv_cos F
> GLIBC_2.38 _ZGVsMxv_cosf F
> +GLIBC_2.38 _ZGVsMxv_sin F
> +GLIBC_2.38 _ZGVsMxv_sinf F
> --
> 2.27.0
>
The 06/28/2023 12:19, Joe Ramsay via Libc-alpha wrote:
> +++ b/sysdeps/aarch64/fpu/sin_advsimd.c
> @@ -0,0 +1,106 @@
> +/* Double-precision vector (Advanced SIMD) sin function.
...
> +float64x2_t VPCS_ATTR V_NAME_D1 (sin) (float64x2_t x)
> +{
> + const struct data *d = ptr_barrier (&data);
> + float64x2_t n, r, r2, r3, r4, y, t1, t2, t3;
> + uint64x2_t odd, cmp, eqz;
> +
> +#if WANT_SIMD_EXCEPT
> + /* Detect |x| <= TinyBound or |x| >= RangeVal. If fenv exceptions are to be
> + triggered correctly, set any special lanes to 1 (which is neutral w.r.t.
> + fenv). These lanes will be fixed by special-case handler later. */
> + uint64x2_t ir = vreinterpretq_u64_f64 (vabsq_f64 (x));
> + cmp = vcgeq_u64 (vsubq_u64 (ir, TinyBound), Thresh);
> + r = vbslq_f64 (cmp, vreinterpretq_f64_u64 (cmp), x);
> +#else
> + r = x;
> + cmp = vcageq_f64 (d->range_val, x);
> + cmp = vceqzq_u64 (cmp); /* cmp = ~cmp. */
> +#endif
> + eqz = vceqzq_f64 (x);
> +
> + /* n = rint(|x|/pi). */
> + n = vfmaq_f64 (d->shift, d->inv_pi, r);
> + odd = vshlq_n_u64 (vreinterpretq_u64_f64 (n), 63);
> + n = vsubq_f64 (n, d->shift);
> +
> + /* r = |x| - n*pi (range reduction into -pi/2 .. pi/2). */
> + r = vfmsq_f64 (r, d->pi_1, n);
> + r = vfmsq_f64 (r, d->pi_2, n);
> + r = vfmsq_f64 (r, d->pi_3, n);
> +
> + /* sin(r) poly approx. */
> + r2 = vmulq_f64 (r, r);
> + r3 = vmulq_f64 (r2, r);
> + r4 = vmulq_f64 (r2, r2);
> +
> + t1 = vfmaq_f64 (C (4), C (5), r2);
> + t2 = vfmaq_f64 (C (2), C (3), r2);
> + t3 = vfmaq_f64 (C (0), C (1), r2);
> +
> + y = vfmaq_f64 (t1, C (6), r4);
> + y = vfmaq_f64 (t2, y, r4);
> + y = vfmaq_f64 (t3, y, r4);
> + y = vfmaq_f64 (r, y, r3);
> +
> + /* Sign of 0 is discarded by polynomial, so copy it back here. */
> + if (__glibc_unlikely (v_any_u64 (eqz)))
> + y = vbslq_f64 (eqz, x, y);
this check is for dealing with the sin(-0.0) case.
but -ffast-math can already break the sign of 0 and libmvec
symbols are supposed to be used with -ffast-math (at least via
gcc auto vectorizer).
so do we need to provide quality guarantees beyond -ffast-math
in libmvec? or can we ignore math tests that check for the sign
of 0 and change the code accordingly.
the wiki does not seem to cover this under "C99 compliance":
https://sourceware.org/glibc/wiki/libmvec
> +
> + if (__glibc_unlikely (v_any_u64 (cmp)))
> + return special_case (x, y, odd, cmp);
> + return vreinterpretq_f64_u64 (veorq_u64 (vreinterpretq_u64_f64 (y), odd));
> +}
@@ -1,10 +1,10 @@
-float-advsimd-funcs = cos
+libmvec-supported-funcs = cos \
+ sin
-double-advsimd-funcs = cos
-
-float-sve-funcs = cos
-
-double-sve-funcs = cos
+float-advsimd-funcs = $(libmvec-supported-funcs)
+double-advsimd-funcs = $(libmvec-supported-funcs)
+float-sve-funcs = $(libmvec-supported-funcs)
+double-sve-funcs = $(libmvec-supported-funcs)
ifeq ($(subdir),mathvec)
libmvec-support = $(addsuffix f_advsimd,$(float-advsimd-funcs)) \
@@ -1,8 +1,12 @@
libmvec {
GLIBC_2.38 {
_ZGVnN2v_cos;
+ _ZGVnN2v_sin;
_ZGVnN4v_cosf;
+ _ZGVnN4v_sinf;
_ZGVsMxv_cos;
_ZGVsMxv_cosf;
+ _ZGVsMxv_sin;
+ _ZGVsMxv_sinf;
}
}
@@ -50,7 +50,10 @@ typedef __SVBool_t __sv_bool_t;
# define __vpcs __attribute__ ((__aarch64_vector_pcs__))
__vpcs __f32x4_t _ZGVnN4v_cosf (__f32x4_t);
+__vpcs __f32x4_t _ZGVnN4v_sinf (__f32x4_t);
+
__vpcs __f64x2_t _ZGVnN2v_cos (__f64x2_t);
+__vpcs __f64x2_t _ZGVnN2v_sin (__f64x2_t);
# undef __ADVSIMD_VEC_MATH_SUPPORTED
#endif /* __ADVSIMD_VEC_MATH_SUPPORTED */
@@ -58,7 +61,10 @@ __vpcs __f64x2_t _ZGVnN2v_cos (__f64x2_t);
#ifdef __SVE_VEC_MATH_SUPPORTED
__sv_f32_t _ZGVsMxv_cosf (__sv_f32_t, __sv_bool_t);
+__sv_f32_t _ZGVsMxv_sinf (__sv_f32_t, __sv_bool_t);
+
__sv_f64_t _ZGVsMxv_cos (__sv_f64_t, __sv_bool_t);
+__sv_f64_t _ZGVsMxv_sin (__sv_f64_t, __sv_bool_t);
# undef __SVE_VEC_MATH_SUPPORTED
#endif /* __SVE_VEC_MATH_SUPPORTED */
new file mode 100644
@@ -0,0 +1,106 @@
+/* Double-precision vector (Advanced SIMD) sin function.
+
+ Copyright (C) 2023 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ 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, see
+ <https://www.gnu.org/licenses/>. */
+
+#include "v_math.h"
+
+static const struct data
+{
+ float64x2_t poly[7];
+ float64x2_t range_val, inv_pi, shift, pi_1, pi_2, pi_3;
+} data = {
+ /* Worst-case error is 2.8 ulp in [-pi/2, pi/2]. */
+ .poly = { V2 (-0x1.555555555547bp-3), V2 (0x1.1111111108a4dp-7),
+ V2 (-0x1.a01a019936f27p-13), V2 (0x1.71de37a97d93ep-19),
+ V2 (-0x1.ae633919987c6p-26), V2 (0x1.60e277ae07cecp-33),
+ V2 (-0x1.9e9540300a1p-41) },
+
+ .range_val = V2 (0x1p23),
+ .inv_pi = V2 (0x1.45f306dc9c883p-2),
+ .pi_1 = V2 (0x1.921fb54442d18p+1),
+ .pi_2 = V2 (0x1.1a62633145c06p-53),
+ .pi_3 = V2 (0x1.c1cd129024e09p-106),
+ .shift = V2 (0x1.8p52),
+};
+
+#if WANT_SIMD_EXCEPT
+# define TinyBound v_u64 (0x3000000000000000) /* asuint64 (0x1p-255). */
+# define Thresh v_u64 (0x1160000000000000) /* RangeVal - TinyBound. */
+#endif
+
+#define C(i) d->poly[i]
+
+static float64x2_t VPCS_ATTR NOINLINE
+special_case (float64x2_t x, float64x2_t y, uint64x2_t odd, uint64x2_t cmp)
+{
+ y = vreinterpretq_f64_u64 (veorq_u64 (vreinterpretq_u64_f64 (y), odd));
+ return v_call_f64 (sin, x, y, cmp);
+}
+
+float64x2_t VPCS_ATTR V_NAME_D1 (sin) (float64x2_t x)
+{
+ const struct data *d = ptr_barrier (&data);
+ float64x2_t n, r, r2, r3, r4, y, t1, t2, t3;
+ uint64x2_t odd, cmp, eqz;
+
+#if WANT_SIMD_EXCEPT
+ /* Detect |x| <= TinyBound or |x| >= RangeVal. If fenv exceptions are to be
+ triggered correctly, set any special lanes to 1 (which is neutral w.r.t.
+ fenv). These lanes will be fixed by special-case handler later. */
+ uint64x2_t ir = vreinterpretq_u64_f64 (vabsq_f64 (x));
+ cmp = vcgeq_u64 (vsubq_u64 (ir, TinyBound), Thresh);
+ r = vbslq_f64 (cmp, vreinterpretq_f64_u64 (cmp), x);
+#else
+ r = x;
+ cmp = vcageq_f64 (d->range_val, x);
+ cmp = vceqzq_u64 (cmp); /* cmp = ~cmp. */
+#endif
+ eqz = vceqzq_f64 (x);
+
+ /* n = rint(|x|/pi). */
+ n = vfmaq_f64 (d->shift, d->inv_pi, r);
+ odd = vshlq_n_u64 (vreinterpretq_u64_f64 (n), 63);
+ n = vsubq_f64 (n, d->shift);
+
+ /* r = |x| - n*pi (range reduction into -pi/2 .. pi/2). */
+ r = vfmsq_f64 (r, d->pi_1, n);
+ r = vfmsq_f64 (r, d->pi_2, n);
+ r = vfmsq_f64 (r, d->pi_3, n);
+
+ /* sin(r) poly approx. */
+ r2 = vmulq_f64 (r, r);
+ r3 = vmulq_f64 (r2, r);
+ r4 = vmulq_f64 (r2, r2);
+
+ t1 = vfmaq_f64 (C (4), C (5), r2);
+ t2 = vfmaq_f64 (C (2), C (3), r2);
+ t3 = vfmaq_f64 (C (0), C (1), r2);
+
+ y = vfmaq_f64 (t1, C (6), r4);
+ y = vfmaq_f64 (t2, y, r4);
+ y = vfmaq_f64 (t3, y, r4);
+ y = vfmaq_f64 (r, y, r3);
+
+ /* Sign of 0 is discarded by polynomial, so copy it back here. */
+ if (__glibc_unlikely (v_any_u64 (eqz)))
+ y = vbslq_f64 (eqz, x, y);
+
+ if (__glibc_unlikely (v_any_u64 (cmp)))
+ return special_case (x, y, odd, cmp);
+ return vreinterpretq_f64_u64 (veorq_u64 (vreinterpretq_u64_f64 (y), odd));
+}
new file mode 100644
@@ -0,0 +1,97 @@
+/* Double-precision vector (SVE) sin function.
+
+ Copyright (C) 2023 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ 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, see
+ <https://www.gnu.org/licenses/>. */
+
+#include "sv_math.h"
+
+static const struct data
+{
+ double inv_pi, half_pi, inv_pi_over_2, pi_over_2_1, pi_over_2_2, pi_over_2_3,
+ shift;
+} data = {
+ /* Polynomial coefficients are hard-wired in the FTMAD instruction. */
+ .inv_pi = 0x1.45f306dc9c883p-2,
+ .half_pi = 0x1.921fb54442d18p+0,
+ .inv_pi_over_2 = 0x1.45f306dc9c882p-1,
+ .pi_over_2_1 = 0x1.921fb50000000p+0,
+ .pi_over_2_2 = 0x1.110b460000000p-26,
+ .pi_over_2_3 = 0x1.1a62633145c07p-54,
+ .shift = 0x1.8p52
+};
+
+#define RangeVal 0x4160000000000000 /* asuint64 (0x1p23). */
+
+static svfloat64_t NOINLINE
+special_case (svfloat64_t x, svfloat64_t y, svbool_t cmp)
+{
+ return sv_call_f64 (sin, x, y, cmp);
+}
+
+/* A fast SVE implementation of sin based on trigonometric
+ instructions (FTMAD, FTSSEL, FTSMUL).
+ Maximum observed error in 2.52 ULP:
+ SV_NAME_D1 (sin)(0x1.2d2b00df69661p+19) got 0x1.10ace8f3e786bp-40
+ want 0x1.10ace8f3e7868p-40. */
+svfloat64_t SV_NAME_D1 (sin) (svfloat64_t x, const svbool_t pg)
+{
+ const struct data *d = ptr_barrier (&data);
+
+ svfloat64_t r = svabs_f64_x (pg, x);
+ svuint64_t sign
+ = sveor_u64_x (pg, svreinterpret_u64_f64 (x), svreinterpret_u64_f64 (r));
+ svbool_t cmp = svcmpge_n_u64 (pg, svreinterpret_u64_f64 (r), RangeVal);
+
+ /* Load first two pio2-related constants to one vector. */
+ svfloat64_t invpio2_and_pio2_1
+ = svld1rq_f64 (svptrue_b64 (), &d->inv_pi_over_2);
+
+ /* n = rint(|x|/(pi/2)). */
+ svfloat64_t q = svmla_lane_f64 (sv_f64 (d->shift), r, invpio2_and_pio2_1, 0);
+ svfloat64_t n = svsub_n_f64_x (pg, q, d->shift);
+
+ /* r = |x| - n*(pi/2) (range reduction into -pi/4 .. pi/4). */
+ r = svmls_lane_f64 (r, n, invpio2_and_pio2_1, 1);
+ r = svmls_n_f64_x (pg, r, n, d->pi_over_2_2);
+ r = svmls_n_f64_x (pg, r, n, d->pi_over_2_3);
+
+ /* Final multiplicative factor: 1.0 or x depending on bit #0 of q. */
+ svfloat64_t f = svtssel_f64 (r, svreinterpret_u64_f64 (q));
+
+ /* sin(r) poly approx. */
+ svfloat64_t r2 = svtsmul_f64 (r, svreinterpret_u64_f64 (q));
+ svfloat64_t y = sv_f64 (0.0);
+ y = svtmad_f64 (y, r2, 7);
+ y = svtmad_f64 (y, r2, 6);
+ y = svtmad_f64 (y, r2, 5);
+ y = svtmad_f64 (y, r2, 4);
+ y = svtmad_f64 (y, r2, 3);
+ y = svtmad_f64 (y, r2, 2);
+ y = svtmad_f64 (y, r2, 1);
+ y = svtmad_f64 (y, r2, 0);
+
+ /* Apply factor. */
+ y = svmul_f64_x (pg, f, y);
+
+ /* sign = y^sign. */
+ y = svreinterpret_f64_u64 (
+ sveor_u64_x (pg, svreinterpret_u64_f64 (y), sign));
+
+ if (__glibc_unlikely (svptest_any (pg, cmp)))
+ return special_case (x, y, cmp);
+ return y;
+}
new file mode 100644
@@ -0,0 +1,99 @@
+/* Single-precision vector (Advanced SIMD) sin function.
+
+ Copyright (C) 2023 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ 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, see
+ <https://www.gnu.org/licenses/>. */
+
+#include "v_math.h"
+
+static const struct data
+{
+ float32x4_t poly[4];
+ float32x4_t range_val, inv_pi, shift, pi_1, pi_2, pi_3;
+} data = {
+ /* 1.886 ulp error. */
+ .poly = { V4 (-0x1.555548p-3f), V4 (0x1.110df4p-7f), V4 (-0x1.9f42eap-13f),
+ V4 (0x1.5b2e76p-19f) },
+
+ .pi_1 = V4 (0x1.921fb6p+1f),
+ .pi_2 = V4 (-0x1.777a5cp-24f),
+ .pi_3 = V4 (-0x1.ee59dap-49f),
+
+ .inv_pi = V4 (0x1.45f306p-2f),
+ .shift = V4 (0x1.8p+23f),
+ .range_val = V4 (0x1p20f)
+};
+
+#if WANT_SIMD_EXCEPT
+# define TinyBound v_u32 (0x21000000) /* asuint32(0x1p-61f). */
+# define Thresh v_u32 (0x28800000) /* RangeVal - TinyBound. */
+#endif
+
+#define C(i) d->poly[i]
+
+static float32x4_t VPCS_ATTR NOINLINE
+special_case (float32x4_t x, float32x4_t y, uint32x4_t odd, uint32x4_t cmp)
+{
+ /* Fall back to scalar code. */
+ y = vreinterpretq_f32_u32 (veorq_u32 (vreinterpretq_u32_f32 (y), odd));
+ return v_call_f32 (sinf, x, y, cmp);
+}
+
+float32x4_t VPCS_ATTR V_NAME_F1 (sin) (float32x4_t x)
+{
+ const struct data *d = ptr_barrier (&data);
+ float32x4_t n, r, r2, y;
+ uint32x4_t odd, cmp, eqz;
+
+#if WANT_SIMD_EXCEPT
+ uint32x4_t ir = vreinterpretq_u32_f32 (vabsq_f32 (x));
+ cmp = vcgeq_u32 (vsubq_u32 (ir, TinyBound), Thresh);
+ /* If fenv exceptions are to be triggered correctly, set any special lanes
+ to 1 (which is neutral w.r.t. fenv). These lanes will be fixed by
+ special-case handler later. */
+ r = vbslq_f32 (cmp, vreinterpretq_f32_u32 (cmp), x);
+#else
+ r = x;
+ cmp = vcageq_f32 (d->range_val, x);
+ cmp = vceqzq_u32 (cmp); /* cmp = ~cmp. */
+#endif
+ eqz = vceqzq_f32 (x);
+
+ /* n = rint(|x|/pi) */
+ n = vfmaq_f32 (d->shift, d->inv_pi, r);
+ odd = vshlq_n_u32 (vreinterpretq_u32_f32 (n), 31);
+ n = vsubq_f32 (n, d->shift);
+
+ /* r = |x| - n*pi (range reduction into -pi/2 .. pi/2) */
+ r = vfmsq_f32 (r, d->pi_1, n);
+ r = vfmsq_f32 (r, d->pi_2, n);
+ r = vfmsq_f32 (r, d->pi_3, n);
+
+ /* y = sin(r) */
+ r2 = vmulq_f32 (r, r);
+ y = vfmaq_f32 (C (2), C (3), r2);
+ y = vfmaq_f32 (C (1), y, r2);
+ y = vfmaq_f32 (C (0), y, r2);
+ y = vfmaq_f32 (r, vmulq_f32 (y, r2), r);
+
+ /* Sign of 0 is discarded by polynomial, so copy it back here. */
+ if (__glibc_unlikely (v_any_u32 (eqz)))
+ y = vbslq_f32 (eqz, x, y);
+
+ if (__glibc_unlikely (v_any_u32 (cmp)))
+ return special_case (x, y, odd, cmp);
+ return vreinterpretq_f32_u32 (veorq_u32 (vreinterpretq_u32_f32 (y), odd));
+}
new file mode 100644
@@ -0,0 +1,96 @@
+/* Single-precision vector (SVE) sin function.
+
+ Copyright (C) 2023 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ 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, see
+ <https://www.gnu.org/licenses/>. */
+
+#include "sv_math.h"
+
+static const struct data
+{
+ float poly[4];
+ /* Pi-related values to be loaded as one quad-word and used with
+ svmla_lane_f32. */
+ float negpi1, negpi2, negpi3, invpi;
+ float shift;
+} data = {
+ .poly = {
+ /* Non-zero coefficients from the degree 9 Taylor series expansion of
+ sin. */
+ -0x1.555548p-3f, 0x1.110df4p-7f, -0x1.9f42eap-13f, 0x1.5b2e76p-19f
+ },
+ .negpi1 = -0x1.921fb6p+1f,
+ .negpi2 = 0x1.777a5cp-24f,
+ .negpi3 = 0x1.ee59dap-49f,
+ .invpi = 0x1.45f306p-2f,
+ .shift = 0x1.8p+23f
+};
+
+#define RangeVal 0x49800000 /* asuint32 (0x1p20f). */
+#define C(i) sv_f32 (d->poly[i])
+
+static svfloat32_t NOINLINE
+special_case (svfloat32_t x, svfloat32_t y, svbool_t cmp)
+{
+ return sv_call_f32 (sinf, x, y, cmp);
+}
+
+/* A fast SVE implementation of sinf.
+ Maximum error: 1.89 ULPs.
+ This maximum error is achieved at multiple values in [-2^18, 2^18]
+ but one example is:
+ SV_NAME_F1 (sin)(0x1.9247a4p+0) got 0x1.fffff6p-1 want 0x1.fffffap-1. */
+svfloat32_t SV_NAME_F1 (sin) (svfloat32_t x, const svbool_t pg)
+{
+ const struct data *d = ptr_barrier (&data);
+
+ svfloat32_t ax = svabs_f32_x (pg, x);
+ svuint32_t sign = sveor_u32_x (pg, svreinterpret_u32_f32 (x),
+ svreinterpret_u32_f32 (ax));
+ svbool_t cmp = svcmpge_n_u32 (pg, svreinterpret_u32_f32 (ax), RangeVal);
+
+ /* pi_vals are a quad-word of helper values - the first 3 elements contain
+ -pi in extended precision, the last contains 1 / pi. */
+ svfloat32_t pi_vals = svld1rq_f32 (svptrue_b32 (), &d->negpi1);
+
+ /* n = rint(|x|/pi). */
+ svfloat32_t n = svmla_lane_f32 (sv_f32 (d->shift), ax, pi_vals, 3);
+ svuint32_t odd = svlsl_n_u32_x (pg, svreinterpret_u32_f32 (n), 31);
+ n = svsub_n_f32_x (pg, n, d->shift);
+
+ /* r = |x| - n*pi (range reduction into -pi/2 .. pi/2). */
+ svfloat32_t r;
+ r = svmla_lane_f32 (ax, n, pi_vals, 0);
+ r = svmla_lane_f32 (r, n, pi_vals, 1);
+ r = svmla_lane_f32 (r, n, pi_vals, 2);
+
+ /* sin(r) approx using a degree 9 polynomial from the Taylor series
+ expansion. Note that only the odd terms of this are non-zero. */
+ svfloat32_t r2 = svmul_f32_x (pg, r, r);
+ svfloat32_t y;
+ y = svmla_f32_x (pg, C (2), r2, C (3));
+ y = svmla_f32_x (pg, C (1), r2, y);
+ y = svmla_f32_x (pg, C (0), r2, y);
+ y = svmla_f32_x (pg, r, r, svmul_f32_x (pg, y, r2));
+
+ /* sign = y^sign^odd. */
+ y = svreinterpret_f32_u32 (sveor_u32_x (pg, svreinterpret_u32_f32 (y),
+ sveor_u32_x (pg, sign, odd)));
+
+ if (__glibc_unlikely (svptest_any (pg, cmp)))
+ return special_case (x, y, cmp);
+ return y;
+}
@@ -24,3 +24,4 @@
#define VEC_TYPE float64x2_t
VPCS_VECTOR_WRAPPER (cos_advsimd, _ZGVnN2v_cos)
+VPCS_VECTOR_WRAPPER (sin_advsimd, _ZGVnN2v_sin)
@@ -33,3 +33,4 @@
}
SVE_VECTOR_WRAPPER (cos_sve, _ZGVsMxv_cos)
+SVE_VECTOR_WRAPPER (sin_sve, _ZGVsMxv_sin)
@@ -24,3 +24,4 @@
#define VEC_TYPE float32x4_t
VPCS_VECTOR_WRAPPER (cosf_advsimd, _ZGVnN4v_cosf)
+VPCS_VECTOR_WRAPPER (sinf_advsimd, _ZGVnN4v_sinf)
@@ -33,3 +33,4 @@
}
SVE_VECTOR_WRAPPER (cosf_sve, _ZGVsMxv_cosf)
+SVE_VECTOR_WRAPPER (sinf_sve, _ZGVsMxv_sinf)
@@ -1257,11 +1257,19 @@ double: 1
float: 1
ldouble: 2
+Function: "sin_advsimd":
+double: 2
+float: 1
+
Function: "sin_downward":
double: 1
float: 1
ldouble: 3
+Function: "sin_sve":
+double: 2
+float: 1
+
Function: "sin_towardzero":
double: 1
float: 1
@@ -1,4 +1,8 @@
GLIBC_2.38 _ZGVnN2v_cos F
+GLIBC_2.38 _ZGVnN2v_sin F
GLIBC_2.38 _ZGVnN4v_cosf F
+GLIBC_2.38 _ZGVnN4v_sinf F
GLIBC_2.38 _ZGVsMxv_cos F
GLIBC_2.38 _ZGVsMxv_cosf F
+GLIBC_2.38 _ZGVsMxv_sin F
+GLIBC_2.38 _ZGVsMxv_sinf F