//===-- Exhaustive test template for math functions -------------*- 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
//
//===----------------------------------------------------------------------===//
#include "src/__support/CPP/type_traits.h"
#include "src/__support/FPUtil/FPBits.h"
#include "src/__support/macros/properties/types.h"
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
#include "utils/MPFRWrapper/MPFRUtils.h"
#include <atomic>
#include <functional>
#include <iostream>
#include <mutex>
#include <sstream>
#include <thread>
#include <vector>
// To test exhaustively for inputs in the range [start, stop) in parallel:
// 1. Define a Checker class with:
// - FloatType: define floating point type to be used.
// - FPBits: fputil::FPBits<FloatType>.
// - StorageType: define bit type for the corresponding floating point type.
// - uint64_t check(start, stop, rounding_mode): a method to test in given
// range for a given rounding mode, which returns the number of
// failures.
// 2. Use LlvmLibcExhaustiveMathTest<Checker> class
// 3. Call: test_full_range(start, stop, nthreads, rounding)
// or test_full_range_all_roundings(start, stop).
// * For single input single output math function, use the convenient template:
// LlvmLibcUnaryOpExhaustiveMathTest<FloatType, Op, Func>.
namespace mpfr = LIBC_NAMESPACE::testing::mpfr;
template <typename OutType, typename InType = OutType>
using UnaryOp = OutType(InType);
template <typename OutType, typename InType, mpfr::Operation Op,
UnaryOp<OutType, InType> Func>
struct UnaryOpChecker : public virtual LIBC_NAMESPACE::testing::Test {
using FloatType = InType;
using FPBits = LIBC_NAMESPACE::fputil::FPBits<FloatType>;
using StorageType = typename FPBits::StorageType;
// Check in a range, return the number of failures.
uint64_t check(StorageType start, StorageType stop,
mpfr::RoundingMode rounding) {
mpfr::ForceRoundingMode r(rounding);
if (!r.success)
return (stop > start);
StorageType bits = start;
uint64_t failed = 0;
do {
FPBits xbits(bits);
FloatType x = xbits.get_val();
bool correct =
TEST_MPFR_MATCH_ROUNDING_SILENTLY(Op, x, Func(x), 0.5, rounding);
failed += (!correct);
// Uncomment to print out failed values.
if (!correct) {
EXPECT_MPFR_MATCH_ROUNDING(Op, x, Func(x), 0.5, rounding);
}
} while (bits++ < stop);
return failed;
}
};
template <typename OutType, typename InType = OutType>
using BinaryOp = OutType(InType, InType);
template <typename OutType, typename InType, mpfr::Operation Op,
BinaryOp<OutType, InType> Func>
struct BinaryOpChecker : public virtual LIBC_NAMESPACE::testing::Test {
using FloatType = InType;
using FPBits = LIBC_NAMESPACE::fputil::FPBits<FloatType>;
using StorageType = typename FPBits::StorageType;
// Check in a range, return the number of failures.
uint64_t check(StorageType x_start, StorageType x_stop, StorageType y_start,
StorageType y_stop, mpfr::RoundingMode rounding) {
mpfr::ForceRoundingMode r(rounding);
if (!r.success)
return x_stop > x_start || y_stop > y_start;
StorageType xbits = x_start;
uint64_t failed = 0;
do {
FloatType x = FPBits(xbits).get_val();
StorageType ybits = y_start;
do {
FloatType y = FPBits(ybits).get_val();
mpfr::BinaryInput<FloatType> input{x, y};
bool correct = TEST_MPFR_MATCH_ROUNDING_SILENTLY(Op, input, Func(x, y),
0.5, rounding);
failed += (!correct);
// Uncomment to print out failed values.
if (!correct) {
EXPECT_MPFR_MATCH_ROUNDING(Op, input, Func(x, y), 0.5, rounding);
}
} while (ybits++ < y_stop);
} while (xbits++ < x_stop);
return failed;
}
};
// Checker class needs inherit from LIBC_NAMESPACE::testing::Test and provide
// StorageType and check method.
template <typename Checker, size_t Increment = 1 << 20>
struct LlvmLibcExhaustiveMathTest
: public virtual LIBC_NAMESPACE::testing::Test,
public Checker {
using FloatType = typename Checker::FloatType;
using FPBits = typename Checker::FPBits;
using StorageType = typename Checker::StorageType;
void explain_failed_range(std::stringstream &msg, StorageType x_begin,
StorageType x_end) {
#ifdef LIBC_TYPES_HAS_FLOAT16
using T = LIBC_NAMESPACE::cpp::conditional_t<
LIBC_NAMESPACE::cpp::is_same_v<FloatType, float16>, float, FloatType>;
#else
using T = FloatType;
#endif
msg << x_begin << " to " << x_end << " [0x" << std::hex << x_begin << ", 0x"
<< x_end << "), [" << std::hexfloat
<< static_cast<T>(FPBits(x_begin).get_val()) << ", "
<< static_cast<T>(FPBits(x_end).get_val()) << ")";
}
void explain_failed_range(std::stringstream &msg, StorageType x_begin,
StorageType x_end, StorageType y_begin,
StorageType y_end) {
msg << "x ";
explain_failed_range(msg, x_begin, x_end);
msg << ", y ";
explain_failed_range(msg, y_begin, y_end);
}
// Break [start, stop) into `nthreads` subintervals and apply *check to each
// subinterval in parallel.
template <typename... T>
void test_full_range(mpfr::RoundingMode rounding, StorageType start,
StorageType stop, T... extra_range_bounds) {
int n_threads = std::thread::hardware_concurrency();
std::vector<std::thread> thread_list;
std::mutex mx_cur_val;
int current_percent = -1;
StorageType current_value = start;
std::atomic<uint64_t> failed(0);
for (int i = 0; i < n_threads; ++i) {
thread_list.emplace_back([&, this]() {
while (true) {
StorageType range_begin, range_end;
int new_percent = -1;
{
std::lock_guard<std::mutex> lock(mx_cur_val);
if (current_value == stop)
return;
range_begin = current_value;
if (stop >= Increment && stop - Increment >= current_value) {
range_end = current_value + Increment;
} else {
range_end = stop;
}
current_value = range_end;
int pc = 100.0 * (range_end - start) / (stop - start);
if (current_percent != pc) {
new_percent = pc;
current_percent = pc;
}
}
if (new_percent >= 0) {
std::stringstream msg;
msg << new_percent << "% is in process \r";
std::cout << msg.str() << std::flush;
}
uint64_t failed_in_range = Checker::check(
range_begin, range_end, extra_range_bounds..., rounding);
if (failed_in_range > 0) {
std::stringstream msg;
msg << "Test failed for " << std::dec << failed_in_range
<< " inputs in range: ";
explain_failed_range(msg, range_begin, range_end,
extra_range_bounds...);
msg << "\n";
std::cerr << msg.str() << std::flush;
failed.fetch_add(failed_in_range);
}
}
});
}
for (auto &thread : thread_list) {
if (thread.joinable()) {
thread.join();
}
}
std::cout << std::endl;
std::cout << "Test " << ((failed > 0) ? "FAILED" : "PASSED") << std::endl;
ASSERT_EQ(failed.load(), uint64_t(0));
}
void test_full_range_all_roundings(StorageType start, StorageType stop) {
std::cout << "-- Testing for FE_TONEAREST in range [0x" << std::hex << start
<< ", 0x" << stop << ") --" << std::dec << std::endl;
test_full_range(mpfr::RoundingMode::Nearest, start, stop);
std::cout << "-- Testing for FE_UPWARD in range [0x" << std::hex << start
<< ", 0x" << stop << ") --" << std::dec << std::endl;
test_full_range(mpfr::RoundingMode::Upward, start, stop);
std::cout << "-- Testing for FE_DOWNWARD in range [0x" << std::hex << start
<< ", 0x" << stop << ") --" << std::dec << std::endl;
test_full_range(mpfr::RoundingMode::Downward, start, stop);
std::cout << "-- Testing for FE_TOWARDZERO in range [0x" << std::hex
<< start << ", 0x" << stop << ") --" << std::dec << std::endl;
test_full_range(mpfr::RoundingMode::TowardZero, start, stop);
};
void test_full_range_all_roundings(StorageType x_start, StorageType x_stop,
StorageType y_start, StorageType y_stop) {
std::cout << "-- Testing for FE_TONEAREST in x range [0x" << std::hex
<< x_start << ", 0x" << x_stop << "), y range [0x" << y_start
<< ", 0x" << y_stop << ") --" << std::dec << std::endl;
test_full_range(mpfr::RoundingMode::Nearest, x_start, x_stop, y_start,
y_stop);
std::cout << "-- Testing for FE_UPWARD in x range [0x" << std::hex
<< x_start << ", 0x" << x_stop << "), y range [0x" << y_start
<< ", 0x" << y_stop << ") --" << std::dec << std::endl;
test_full_range(mpfr::RoundingMode::Upward, x_start, x_stop, y_start,
y_stop);
std::cout << "-- Testing for FE_DOWNWARD in x range [0x" << std::hex
<< x_start << ", 0x" << x_stop << "), y range [0x" << y_start
<< ", 0x" << y_stop << ") --" << std::dec << std::endl;
test_full_range(mpfr::RoundingMode::Downward, x_start, x_stop, y_start,
y_stop);
std::cout << "-- Testing for FE_TOWARDZERO in x range [0x" << std::hex
<< x_start << ", 0x" << x_stop << "), y range [0x" << y_start
<< ", 0x" << y_stop << ") --" << std::dec << std::endl;
test_full_range(mpfr::RoundingMode::TowardZero, x_start, x_stop, y_start,
y_stop);
};
};
template <typename FloatType, mpfr::Operation Op, UnaryOp<FloatType> Func>
using LlvmLibcUnaryOpExhaustiveMathTest =
LlvmLibcExhaustiveMathTest<UnaryOpChecker<FloatType, FloatType, Op, Func>>;
template <typename OutType, typename InType, mpfr::Operation Op,
UnaryOp<OutType, InType> Func>
using LlvmLibcUnaryNarrowingOpExhaustiveMathTest =
LlvmLibcExhaustiveMathTest<UnaryOpChecker<OutType, InType, Op, Func>>;
template <typename FloatType, mpfr::Operation Op, BinaryOp<FloatType> Func>
using LlvmLibcBinaryOpExhaustiveMathTest =
LlvmLibcExhaustiveMathTest<BinaryOpChecker<FloatType, FloatType, Op, Func>,
1 << 2>;
Codebase Browser
llvm