f320fefc4a
Implement correctly rounded `erff` functions. For `x >= 4`, `erff(x) = 1` for `FE_TONEAREST` or `FE_UPWARD`, `0x1.ffffep-1` for `FE_DOWNWARD` or `FE_TOWARDZERO`. For `0 <= x < 4`, we divide into 32 sub-intervals of length `1/8`, and use a degree-15 odd polynomial to approximate `erff(x)` in each sub-interval: ``` erff(x) ~ x * (c0 + c1 * x^2 + c2 * x^4 + ... + c7 * x^14). ``` For `x < 0`, we can use the same formula as above, since the odd part is factored out. Performance tested with `perf.sh` tool from the CORE-MATH project on AMD Ryzen 9 5900X: Reciprocal throughput (clock cycles / op) ``` $ ./perf.sh erff --path2 GNU libc version: 2.35 GNU libc release: stable -- CORE-MATH reciprocal throughput -- with -march=native (with FMA instructions) [####################] 100 % Ntrial = 20 ; Min = 11.790 + 0.182 clc/call; Median-Min = 0.154 clc/call; Max = 12.255 clc/call; -- CORE-MATH reciprocal throughput -- with -march=x86-64-v2 (without FMA instructions) [####################] 100 % Ntrial = 20 ; Min = 14.205 + 0.151 clc/call; Median-Min = 0.159 clc/call; Max = 15.893 clc/call; -- System LIBC reciprocal throughput -- [####################] 100 % Ntrial = 20 ; Min = 45.519 + 0.445 clc/call; Median-Min = 0.552 clc/call; Max = 46.345 clc/call; -- LIBC reciprocal throughput -- with -mavx2 -mfma (with FMA instructions) [####################] 100 % Ntrial = 20 ; Min = 9.595 + 0.214 clc/call; Median-Min = 0.220 clc/call; Max = 9.887 clc/call; -- LIBC reciprocal throughput -- with -msse4.2 (without FMA instructions) [####################] 100 % Ntrial = 20 ; Min = 10.223 + 0.190 clc/call; Median-Min = 0.222 clc/call; Max = 10.474 clc/call; ``` and latency (clock cycles / op): ``` $ ./perf.sh erff --path2 GNU libc version: 2.35 GNU libc release: stable -- CORE-MATH latency -- with -march=native (with FMA instructions) [####################] 100 % Ntrial = 20 ; Min = 38.566 + 0.391 clc/call; Median-Min = 0.503 clc/call; Max = 39.170 clc/call; -- CORE-MATH latency -- with -march=x86-64-v2 (without FMA instructions) [####################] 100 % Ntrial = 20 ; Min = 43.223 + 0.667 clc/call; Median-Min = 0.680 clc/call; Max = 43.913 clc/call; -- System LIBC latency -- [####################] 100 % Ntrial = 20 ; Min = 111.613 + 1.267 clc/call; Median-Min = 1.696 clc/call; Max = 113.444 clc/call; -- LIBC latency -- with -mavx2 -mfma (with FMA instructions) [####################] 100 % Ntrial = 20 ; Min = 40.138 + 0.410 clc/call; Median-Min = 0.536 clc/call; Max = 40.729 clc/call; -- LIBC latency -- with -msse4.2 (without FMA instructions) [####################] 100 % Ntrial = 20 ; Min = 44.858 + 0.872 clc/call; Median-Min = 0.814 clc/call; Max = 46.019 clc/call; ``` Reviewed By: michaelrj Differential Revision: https://reviews.llvm.org/D153683
107 lines
3.3 KiB
C++
107 lines
3.3 KiB
C++
//===-- Unittests for erff ------------------------------------------------===//
|
|
//
|
|
// 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/__support/FPUtil/FPBits.h"
|
|
#include "src/math/erff.h"
|
|
#include "test/UnitTest/FPMatcher.h"
|
|
#include "test/UnitTest/Test.h"
|
|
#include "utils/MPFRWrapper/MPFRUtils.h"
|
|
#include <math.h>
|
|
|
|
#include <errno.h>
|
|
#include <stdint.h>
|
|
|
|
namespace mpfr = __llvm_libc::testing::mpfr;
|
|
using __llvm_libc::testing::tlog;
|
|
|
|
DECLARE_SPECIAL_CONSTANTS(float)
|
|
|
|
TEST(LlvmLibcErffTest, SpecialNumbers) {
|
|
EXPECT_FP_EQ_ALL_ROUNDING(aNaN, __llvm_libc::erff(aNaN));
|
|
EXPECT_FP_EQ_ALL_ROUNDING(1.0f, __llvm_libc::erff(inf));
|
|
EXPECT_FP_EQ_ALL_ROUNDING(-1.0f, __llvm_libc::erff(neg_inf));
|
|
EXPECT_FP_EQ_ALL_ROUNDING(zero, __llvm_libc::erff(zero));
|
|
EXPECT_FP_EQ_ALL_ROUNDING(neg_zero, __llvm_libc::erff(neg_zero));
|
|
}
|
|
|
|
TEST(LlvmLibcErffTest, TrickyInputs) {
|
|
constexpr int N = 2;
|
|
constexpr uint32_t INPUTS[N] = {
|
|
0x3f65'9229U, // |x| = 0x1.cb2452p-1f
|
|
0x4004'1e6aU, // |x| = 0x1.083cd4p+1f
|
|
};
|
|
for (int i = 0; i < N; ++i) {
|
|
float x = float(FPBits(INPUTS[i]));
|
|
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Erf, x,
|
|
__llvm_libc::erff(x), 0.5);
|
|
EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Erf, -x,
|
|
__llvm_libc::erff(-x), 0.5);
|
|
}
|
|
}
|
|
|
|
TEST(LlvmLibcErffTest, InFloatRange) {
|
|
constexpr uint32_t COUNT = 234561;
|
|
constexpr uint32_t START = 0; // 0
|
|
constexpr uint32_t STOP = 0x4080'0000U; // 4.0f
|
|
|
|
constexpr uint64_t STEP = (STOP - START) / COUNT;
|
|
|
|
auto test = [&](mpfr::RoundingMode rounding_mode) {
|
|
mpfr::ForceRoundingMode __r(rounding_mode);
|
|
if (!__r.success)
|
|
return;
|
|
|
|
uint32_t fails = 0;
|
|
uint32_t count = 0;
|
|
uint32_t cc = 0;
|
|
float mx, mr = 0.0;
|
|
double tol = 0.5;
|
|
|
|
for (uint32_t i = 0, v = START; i <= COUNT; ++i, v += STEP) {
|
|
float x = FPBits(v).get_val();
|
|
if (isnan(x))
|
|
continue;
|
|
|
|
float result = __llvm_libc::erff(x);
|
|
++cc;
|
|
if (isnan(result))
|
|
continue;
|
|
|
|
++count;
|
|
if (!TEST_MPFR_MATCH_ROUNDING_SILENTLY(mpfr::Operation::Erf, x, result,
|
|
0.5, rounding_mode)) {
|
|
++fails;
|
|
while (!TEST_MPFR_MATCH_ROUNDING_SILENTLY(mpfr::Operation::Erf, x,
|
|
result, tol, rounding_mode)) {
|
|
mx = x;
|
|
mr = result;
|
|
tol *= 2.0;
|
|
}
|
|
}
|
|
}
|
|
tlog << " Log failed: " << fails << "/" << count << "/" << cc
|
|
<< " tests.\n";
|
|
tlog << " Max ULPs is at most: " << static_cast<uint64_t>(tol) << ".\n";
|
|
if (fails) {
|
|
EXPECT_MPFR_MATCH(mpfr::Operation::Erf, mx, mr, 0.5, rounding_mode);
|
|
}
|
|
};
|
|
|
|
tlog << " Test Rounding To Nearest...\n";
|
|
test(mpfr::RoundingMode::Nearest);
|
|
|
|
tlog << " Test Rounding Downward...\n";
|
|
test(mpfr::RoundingMode::Downward);
|
|
|
|
tlog << " Test Rounding Upward...\n";
|
|
test(mpfr::RoundingMode::Upward);
|
|
|
|
tlog << " Test Rounding Toward Zero...\n";
|
|
test(mpfr::RoundingMode::TowardZero);
|
|
}
|