diff --git a/libc/config/linux/x86_64/entrypoints.txt b/libc/config/linux/x86_64/entrypoints.txt index 0c54fb267f8550..9f36c24ec61ecb 100644 --- a/libc/config/linux/x86_64/entrypoints.txt +++ b/libc/config/linux/x86_64/entrypoints.txt @@ -576,6 +576,7 @@ if(LIBC_TYPES_HAS_FLOAT16) libc.src.math.canonicalizef16 libc.src.math.ceilf16 libc.src.math.copysignf16 + libc.src.math.exp2f16 libc.src.math.expf16 libc.src.math.f16add libc.src.math.f16addf diff --git a/libc/docs/math/index.rst b/libc/docs/math/index.rst index 14ef59eaa03f10..193e0675357ca2 100644 --- a/libc/docs/math/index.rst +++ b/libc/docs/math/index.rst @@ -290,7 +290,7 @@ Higher Math Functions +-----------+------------------+-----------------+------------------------+----------------------+------------------------+------------------------+----------------------------+ | exp10m1 | | | | | | 7.12.6.3 | F.10.3.3 | +-----------+------------------+-----------------+------------------------+----------------------+------------------------+------------------------+----------------------------+ -| exp2 | |check| | |check| | | | | 7.12.6.4 | F.10.3.4 | +| exp2 | |check| | |check| | | |check| | | 7.12.6.4 | F.10.3.4 | +-----------+------------------+-----------------+------------------------+----------------------+------------------------+------------------------+----------------------------+ | exp2m1 | |check| | | | | | 7.12.6.5 | F.10.3.5 | +-----------+------------------+-----------------+------------------------+----------------------+------------------------+------------------------+----------------------------+ diff --git a/libc/spec/stdc.td b/libc/spec/stdc.td index 506b1c6e74fa64..400b673953a27b 100644 --- a/libc/spec/stdc.td +++ b/libc/spec/stdc.td @@ -582,6 +582,7 @@ def StdC : StandardSpec<"stdc"> { FunctionSpec<"exp2", RetValSpec, [ArgSpec]>, FunctionSpec<"exp2f", RetValSpec, [ArgSpec]>, + GuardedFunctionSpec<"exp2f16", RetValSpec, [ArgSpec], "LIBC_TYPES_HAS_FLOAT16">, FunctionSpec<"exp2m1f", RetValSpec, [ArgSpec]>, diff --git a/libc/src/math/CMakeLists.txt b/libc/src/math/CMakeLists.txt index aec94d41ad0868..1730eec1818776 100644 --- a/libc/src/math/CMakeLists.txt +++ b/libc/src/math/CMakeLists.txt @@ -110,6 +110,7 @@ add_math_entrypoint_object(expf16) add_math_entrypoint_object(exp2) add_math_entrypoint_object(exp2f) +add_math_entrypoint_object(exp2f16) add_math_entrypoint_object(exp2m1f) diff --git a/libc/src/math/exp2f16.h b/libc/src/math/exp2f16.h new file mode 100644 index 00000000000000..71361b997ae8e6 --- /dev/null +++ b/libc/src/math/exp2f16.h @@ -0,0 +1,21 @@ +//===-- Implementation header for exp2f16 -----------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_LIBC_SRC_MATH_EXP2F16_H +#define LLVM_LIBC_SRC_MATH_EXP2F16_H + +#include "src/__support/macros/config.h" +#include "src/__support/macros/properties/types.h" + +namespace LIBC_NAMESPACE_DECL { + +float16 exp2f16(float16 x); + +} // namespace LIBC_NAMESPACE_DECL + +#endif // LLVM_LIBC_SRC_MATH_EXP2F16_H diff --git a/libc/src/math/generic/CMakeLists.txt b/libc/src/math/generic/CMakeLists.txt index 2fe6cc4d39d946..7574f6c22bc17c 100644 --- a/libc/src/math/generic/CMakeLists.txt +++ b/libc/src/math/generic/CMakeLists.txt @@ -1395,6 +1395,28 @@ add_entrypoint_object( -O3 ) +add_entrypoint_object( + exp2f16 + SRCS + exp2f16.cpp + HDRS + ../exp2f16.h + DEPENDS + libc.hdr.errno_macros + libc.hdr.fenv_macros + libc.src.__support.CPP.array + libc.src.__support.FPUtil.except_value_utils + libc.src.__support.FPUtil.fenv_impl + libc.src.__support.FPUtil.fp_bits + libc.src.__support.FPUtil.multiply_add + libc.src.__support.FPUtil.nearest_integer + libc.src.__support.FPUtil.polyeval + libc.src.__support.FPUtil.rounding_mode + libc.src.__support.macros.optimization + COMPILE_OPTIONS + -O3 +) + add_entrypoint_object( exp2m1f SRCS diff --git a/libc/src/math/generic/exp2f16.cpp b/libc/src/math/generic/exp2f16.cpp new file mode 100644 index 00000000000000..3f18ab9166a854 --- /dev/null +++ b/libc/src/math/generic/exp2f16.cpp @@ -0,0 +1,134 @@ +//===-- Half-precision 2^x function ---------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/exp2f16.h" +#include "hdr/errno_macros.h" +#include "hdr/fenv_macros.h" +#include "src/__support/CPP/array.h" +#include "src/__support/FPUtil/FEnvImpl.h" +#include "src/__support/FPUtil/FPBits.h" +#include "src/__support/FPUtil/PolyEval.h" +#include "src/__support/FPUtil/except_value_utils.h" +#include "src/__support/FPUtil/multiply_add.h" +#include "src/__support/FPUtil/nearest_integer.h" +#include "src/__support/FPUtil/rounding_mode.h" +#include "src/__support/common.h" +#include "src/__support/macros/config.h" +#include "src/__support/macros/optimization.h" + +namespace LIBC_NAMESPACE_DECL { + +static constexpr fputil::ExceptValues EXP2F16_EXCEPTS = {{ + // (input, RZ output, RU offset, RD offset, RN offset) + // x = 0x1.714p-11, exp2f16(x) = 0x1p+0 (RZ) + {0x11c5U, 0x3c00U, 1U, 0U, 1U}, + // x = -0x1.558p-4, exp2f16(x) = 0x1.e34p-1 (RZ) + {0xad56U, 0x3b8dU, 1U, 0U, 0U}, + // x = -0x1.d5cp-4, exp2f16(x) = 0x1.d8cp-1 (RZ) + {0xaf57U, 0x3b63U, 1U, 0U, 0U}, +}}; + +// Generated by Sollya with the following commands: +// > display = hexadecimal; +// > for i from 0 to 7 do printsingle(round(2^(i * 2^-3), SG, RN)); +static constexpr cpp::array EXP2_MID_BITS = { + 0x3f80'0000U, 0x3f8b'95c2U, 0x3f98'37f0U, 0x3fa5'fed7U, + 0x3fb5'04f3U, 0x3fc5'672aU, 0x3fd7'44fdU, 0x3fea'c0c7U, +}; + +LLVM_LIBC_FUNCTION(float16, exp2f16, (float16 x)) { + using FPBits = fputil::FPBits; + FPBits x_bits(x); + + uint16_t x_u = x_bits.uintval(); + uint16_t x_abs = x_u & 0x7fffU; + + // When |x| >= 16, or x is NaN. + if (LIBC_UNLIKELY(x_abs >= 0x4c00U)) { + // exp2(NaN) = NaN + if (x_bits.is_nan()) { + if (x_bits.is_signaling_nan()) { + fputil::raise_except_if_required(FE_INVALID); + return FPBits::quiet_nan().get_val(); + } + + return x; + } + + // When x >= 16. + if (x_bits.is_pos()) { + // exp2(+inf) = +inf + if (x_bits.is_inf()) + return FPBits::inf().get_val(); + + switch (fputil::quick_get_round()) { + case FE_TONEAREST: + case FE_UPWARD: + fputil::set_errno_if_required(ERANGE); + fputil::raise_except_if_required(FE_OVERFLOW); + return FPBits::inf().get_val(); + default: + return FPBits::max_normal().get_val(); + } + } + + // When x <= -25. + if (x_u >= 0xce40U) { + // exp2(-inf) = +0 + if (x_bits.is_inf()) + return FPBits::zero().get_val(); + + fputil::set_errno_if_required(ERANGE); + fputil::raise_except_if_required(FE_UNDERFLOW | FE_INEXACT); + + if (fputil::fenv_is_round_up()) + return FPBits::min_subnormal().get_val(); + return FPBits::zero().get_val(); + } + } + + if (auto r = EXP2F16_EXCEPTS.lookup(x_u); LIBC_UNLIKELY(r.has_value())) + return r.value(); + + // For -25 < x < 16, to compute 2^x, we perform the following range reduction: + // find hi, mid, lo, such that: + // x = hi + mid + lo, in which + // hi is an integer, + // mid * 2^3 is an integer, + // -2^(-4) <= lo < 2^(-4). + // In particular, + // hi + mid = round(x * 2^3) * 2^(-3). + // Then, + // 2^x = 2^(hi + mid + lo) = 2^hi * 2^mid * 2^lo. + // We store 2^mid in the lookup table EXP2_MID_BITS, and compute 2^hi * 2^mid + // by adding hi to the exponent field of 2^mid. 2^lo is computed using a + // degree-3 minimax polynomial generated by Sollya. + + float xf = x; + float kf = fputil::nearest_integer(xf * 0x1.0p+3f); + int x_hi_mid = static_cast(kf); + int x_hi = x_hi_mid >> 3; + int x_mid = x_hi_mid & 0x7; + // lo = x - (hi + mid) = round(x * 2^3) * (-2^(-3)) + x + float lo = fputil::multiply_add(kf, -0x1.0p-3f, xf); + + uint32_t exp2_hi_mid_bits = + EXP2_MID_BITS[x_mid] + + static_cast(x_hi << fputil::FPBits::FRACTION_LEN); + float exp2_hi_mid = fputil::FPBits(exp2_hi_mid_bits).get_val(); + // Degree-3 minimax polynomial generated by Sollya with the following + // commands: + // > display = hexadecimal; + // > P = fpminimax((2^x - 1)/x, 2, [|SG...|], [-2^-4, 2^-4]); + // > 1 + x * P; + float exp2_lo = fputil::polyeval(lo, 0x1p+0f, 0x1.62e43p-1f, 0x1.ec0aa6p-3f, + 0x1.c6b4a6p-5f); + return static_cast(exp2_hi_mid * exp2_lo); +} + +} // namespace LIBC_NAMESPACE_DECL diff --git a/libc/test/src/math/CMakeLists.txt b/libc/test/src/math/CMakeLists.txt index ecc8ff139edcc0..7cb24f85170bc8 100644 --- a/libc/test/src/math/CMakeLists.txt +++ b/libc/test/src/math/CMakeLists.txt @@ -939,6 +939,19 @@ add_fp_unittest( libc.src.math.expf16 ) +add_fp_unittest( + exp2_test + NEED_MPFR + SUITE + libc-math-unittests + SRCS + exp2_test.cpp + DEPENDS + libc.src.errno.errno + libc.src.math.exp2 + libc.src.__support.FPUtil.fp_bits +) + add_fp_unittest( exp2f_test NEED_MPFR @@ -953,16 +966,14 @@ add_fp_unittest( ) add_fp_unittest( - exp2_test - NEED_MPFR - SUITE - libc-math-unittests - SRCS - exp2_test.cpp - DEPENDS - libc.src.errno.errno - libc.src.math.exp2 - libc.src.__support.FPUtil.fp_bits + exp2f16_test + NEED_MPFR + SUITE + libc-math-unittests + SRCS + exp2f16_test.cpp + DEPENDS + libc.src.math.exp2f16 ) add_fp_unittest( diff --git a/libc/test/src/math/exp2f16_test.cpp b/libc/test/src/math/exp2f16_test.cpp new file mode 100644 index 00000000000000..503d8c2d89d941 --- /dev/null +++ b/libc/test/src/math/exp2f16_test.cpp @@ -0,0 +1,40 @@ +//===-- Exhaustive test for exp2f16 ---------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "src/math/exp2f16.h" +#include "test/UnitTest/FPMatcher.h" +#include "test/UnitTest/Test.h" +#include "utils/MPFRWrapper/MPFRUtils.h" + +using LlvmLibcExp2f16Test = LIBC_NAMESPACE::testing::FPTest; + +namespace mpfr = LIBC_NAMESPACE::testing::mpfr; + +// Range: [0, Inf]; +static constexpr uint16_t POS_START = 0x0000U; +static constexpr uint16_t POS_STOP = 0x7c00U; + +// Range: [-Inf, 0]; +static constexpr uint16_t NEG_START = 0x8000U; +static constexpr uint16_t NEG_STOP = 0xfc00U; + +TEST_F(LlvmLibcExp2f16Test, PositiveRange) { + for (uint16_t v = POS_START; v <= POS_STOP; ++v) { + float16 x = FPBits(v).get_val(); + EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x, + LIBC_NAMESPACE::exp2f16(x), 0.5); + } +} + +TEST_F(LlvmLibcExp2f16Test, NegativeRange) { + for (uint16_t v = NEG_START; v <= NEG_STOP; ++v) { + float16 x = FPBits(v).get_val(); + EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x, + LIBC_NAMESPACE::exp2f16(x), 0.5); + } +} diff --git a/libc/test/src/math/performance_testing/CMakeLists.txt b/libc/test/src/math/performance_testing/CMakeLists.txt index b43d21a242f359..09211537d93f43 100644 --- a/libc/test/src/math/performance_testing/CMakeLists.txt +++ b/libc/test/src/math/performance_testing/CMakeLists.txt @@ -164,6 +164,17 @@ add_perf_binary( -fno-builtin ) +add_perf_binary( + exp2f16_perf + SRCS + exp2f16_perf.cpp + DEPENDS + .single_input_single_output_diff + libc.src.math.exp2f16 + COMPILE_OPTIONS + -fno-builtin +) + add_perf_binary( expf_perf SRCS diff --git a/libc/test/src/math/performance_testing/exp2f16_perf.cpp b/libc/test/src/math/performance_testing/exp2f16_perf.cpp new file mode 100644 index 00000000000000..aa58de2476f1a7 --- /dev/null +++ b/libc/test/src/math/performance_testing/exp2f16_perf.cpp @@ -0,0 +1,22 @@ +//===-- Performance test for exp2f16 --------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "SingleInputSingleOutputPerf.h" + +#include "src/math/exp2f16.h" + +// LLVM libc might be the only libc implementation with support for float16 math +// functions currently. We can't compare our float16 functions against the +// system libc, so we compare them against this placeholder function. +static float16 placeholderf16(float16 x) { return x; } + +int main() { + SINGLE_INPUT_SINGLE_OUTPUT_PERF_EX(float16, LIBC_NAMESPACE::exp2f16, + ::placeholderf16, 20'000, + "exp2f16_perf.log") +} diff --git a/libc/test/src/math/smoke/CMakeLists.txt b/libc/test/src/math/smoke/CMakeLists.txt index ebd9ca02d08e8d..07d5d78d579960 100644 --- a/libc/test/src/math/smoke/CMakeLists.txt +++ b/libc/test/src/math/smoke/CMakeLists.txt @@ -1029,6 +1029,18 @@ add_fp_unittest( libc.src.math.expf16 ) +add_fp_unittest( + exp2_test + SUITE + libc-math-smoke-tests + SRCS + exp2_test.cpp + DEPENDS + libc.src.errno.errno + libc.src.math.exp2 + libc.src.__support.FPUtil.fp_bits +) + add_fp_unittest( exp2f_test SUITE @@ -1042,15 +1054,15 @@ add_fp_unittest( ) add_fp_unittest( - exp2_test - SUITE - libc-math-smoke-tests - SRCS - exp2_test.cpp - DEPENDS - libc.src.errno.errno - libc.src.math.exp2 - libc.src.__support.FPUtil.fp_bits + exp2f16_test + SUITE + libc-math-smoke-tests + SRCS + exp2f16_test.cpp + DEPENDS + libc.hdr.fenv_macros + libc.src.errno.errno + libc.src.math.exp2f16 ) add_fp_unittest( diff --git a/libc/test/src/math/smoke/exp2f16_test.cpp b/libc/test/src/math/smoke/exp2f16_test.cpp new file mode 100644 index 00000000000000..cd87e6134557a5 --- /dev/null +++ b/libc/test/src/math/smoke/exp2f16_test.cpp @@ -0,0 +1,65 @@ +//===-- Unittests for exp2f16 ---------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "hdr/fenv_macros.h" +#include "src/errno/libc_errno.h" +#include "src/math/exp2f16.h" +#include "test/UnitTest/FPMatcher.h" +#include "test/UnitTest/Test.h" + +using LlvmLibcExp2f16Test = LIBC_NAMESPACE::testing::FPTest; + +TEST_F(LlvmLibcExp2f16Test, SpecialNumbers) { + LIBC_NAMESPACE::libc_errno = 0; + + EXPECT_FP_EQ_ALL_ROUNDING(aNaN, LIBC_NAMESPACE::exp2f16(aNaN)); + EXPECT_MATH_ERRNO(0); + + EXPECT_FP_EQ_WITH_EXCEPTION(aNaN, LIBC_NAMESPACE::exp2f16(sNaN), FE_INVALID); + EXPECT_MATH_ERRNO(0); + + EXPECT_FP_EQ_ALL_ROUNDING(inf, LIBC_NAMESPACE::exp2f16(inf)); + EXPECT_MATH_ERRNO(0); + + EXPECT_FP_EQ_ALL_ROUNDING(static_cast(zero), + LIBC_NAMESPACE::exp2f16(neg_inf)); + EXPECT_MATH_ERRNO(0); + + EXPECT_FP_EQ_ALL_ROUNDING(static_cast(1.0f), + LIBC_NAMESPACE::exp2f16(zero)); + EXPECT_MATH_ERRNO(0); + + EXPECT_FP_EQ_ALL_ROUNDING(static_cast(1.0f), + LIBC_NAMESPACE::exp2f16(neg_zero)); + EXPECT_MATH_ERRNO(0); +} + +TEST_F(LlvmLibcExp2f16Test, Overflow) { + LIBC_NAMESPACE::libc_errno = 0; + + EXPECT_FP_EQ_WITH_EXCEPTION(inf, LIBC_NAMESPACE::exp2f16(max_normal), + FE_OVERFLOW); + EXPECT_MATH_ERRNO(ERANGE); + + EXPECT_FP_EQ_WITH_EXCEPTION( + inf, LIBC_NAMESPACE::exp2f16(static_cast(16.0)), FE_OVERFLOW); + EXPECT_MATH_ERRNO(ERANGE); +} + +TEST_F(LlvmLibcExp2f16Test, Underflow) { + LIBC_NAMESPACE::libc_errno = 0; + + EXPECT_FP_EQ_WITH_EXCEPTION(zero, LIBC_NAMESPACE::exp2f16(neg_max_normal), + FE_UNDERFLOW | FE_INEXACT); + EXPECT_MATH_ERRNO(ERANGE); + + EXPECT_FP_EQ_WITH_EXCEPTION( + zero, LIBC_NAMESPACE::exp2f16(static_cast(-25.0)), + FE_UNDERFLOW | FE_INEXACT); + EXPECT_MATH_ERRNO(ERANGE); +}