[libc] Add multithreading support for exhaustive testing and MPFRUtils.

[lntue]

Summary

Add threading support for exhaustive testing and MPFRUtils.

[michaelrj]

libc/utils/UnitTest/FPMatcher.cpp

70–71

do these templates still work with the new code? It looks like you replaced the function they were using.

[sivachandra]

libc/test/src/math/exhaustive/exhaustive_test.hpp

1 ↗

(On Diff #398959)

The LLVM style is to use a .h extension and C++ in the license header.

https://llvm.org/docs/CodingStandards.html#self-contained-headers

15 ↗

(On Diff #398959)

We cannot include any of these C++ headers. The best would be to implement the testFullRange method in a .cpp file and explicitly instantiate all the variants.

Or, even simpler, exhaustive tests are meaningful only for single-precision functions. So, why not avoid the template and have a simple non-template implementation in a .cpp file? You wouldn't need the start and stop args to testFullRange.

24 ↗

(On Diff #398959)

Instead of taking an argument for number of threads, can we may be use std::thread::hardware_concurrency?

24 ↗

(On Diff #398959)

testFullRange should be named test_full_range.

libc/test/src/math/exhaustive/logf_test.cpp

10

We cannot include C++ headers in a test also. See below for a possible solution for your current use case.

23

It seems to me that this function need not be a template? As in, the rounding mode can be an arg? You will need to add a rounding mode arg to testFullRange also I think.

libc/utils/MPFRWrapper/MPFRUtils.cpp

570–571

It's not clear to me as to why you need a stringstream. Can you explain why?

[lntue]

Move exhaustive_test implementation to .cpp file.

[lntue]

libc/test/src/math/exhaustive/exhaustive_test.hpp

15 ↗

(On Diff #398959)

Moved to .cpp file.

The start and stop args are needed, even just for single-precision, since different functions might have different range of meaningful inputs. For example, logf can take the whole finite range, but expf take a much smaller range, or asin, acos will only produce finite outputs for inputs from [-1, 1].

24 ↗

(On Diff #398959)

Sometime I found myself needed to lower the number of threads, or even set it to 1. Since we are not allowed to include <thread> in here and in exhaustive_test.h, I don't think we can default it to std::thread::hardware_concurrency. Leave it hard-coded for now.

libc/test/src/math/exhaustive/logf_test.cpp

23

I don't think rounding mode information should be included in test_full_range, as their sole purpose is to break down the input range and run it in parallel. So in order to move test_full_range implementation to .cpp file, the testing function has to have a fixed signature. That leave template parameter as the cleanest way to pass rounding mode to each testing function.

libc/utils/MPFRWrapper/MPFRUtils.cpp

570–571

stringstream is needed so that the error messages are printed without interleaving each other when running concurrently.

libc/utils/UnitTest/FPMatcher.cpp

70–71

They are still being used by the default FPMatcher::explainError at libc/utils/UnitTest/FPMatcher.hpp:53-54.

[sivachandra]

libc/test/src/math/exhaustive/exhaustive_test.h

26

Why is using a method pointer over an overridable virtual method with an additional rounding mode arg better? FWIW, method pointers are like virtual functions.

libc/test/src/math/exhaustive/logf_test.cpp

23

I am not sure what "including" rounding mode information in test_full_range would me. But, with the virtual function setup, it will be like this:

test_full_range(..., RoundingMode rounding_mode) {
  check(..., rounding_mode);
}

And it will avoid all the function pointers in the tests below. Also, the template arg is not deducible so there is not benefit to making it a template.

An additional note: Tests which don't need rounding mode will just ignore that arg - so there has to be a default.

libc/utils/MPFRWrapper/MPFRUtils.cpp

570–571

Ah, thanks. Can you add a note at a suitable place in this file?

[lntue]

[libc] Add multithreading support for exhaustive testing and MPFRUtils.

[lntue]

Add comments about the usage of std::stringstream.

[lntue]

libc/test/src/math/exhaustive/exhaustive_test.h

26

See the comment below in logf_test.cpp.

libc/test/src/math/exhaustive/logf_test.cpp

23

It's exactly passing rounding_mode directly to test_full_range that I didn't like and preferred method pointer over virtual function. Since if other tests need different parameters to execute, similar to rounding_mode, then they will have to pass to test_full_range, and all other overridden functions would have to be updated to carry more unused parameters.

Without template parameters (since its implementations is not in the header) and std::function, I found method pointers is the next easiest way to allow each test to add their own required parameters individually without affecting other tests.

Nonetheless, I updated to use virtual function in here, and we can change to method pointers later if more tests need different parameters.

[sivachandra]

libc/test/src/math/exhaustive/logf_test.cpp

23

Ah - this sounds like, if you really need more parameterization in future, then we should parameterize the test class and not the test method? As in,

template <mpfr::RoundingMode Rounding>
class LlvmLibcLogfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
  ...
};

Virtual methods are there essentially there to avoid such "poor man's C++" one can setup using member function pointers. So, I think this virtual function based solution is more idiomatic.

[lntue]

Sync.

libc/cmake/modules/LLVMLibCTestRules.cmake

 # Usage
 #    add_libc_unittest(
 #      <target name>
 #      SUITE <name of the suite this test belongs to>
 #      SRCS  <list of .cpp files for the test>
 #      HDRS  <list of .h files for the test>
 #      DEPENDS <list of dependencies>
 #      COMPILE_OPTIONS <list of special compile options for this target>
+#      LINK_OPTIONS <list of special linking options for this target>
 #    )
 function(add_libc_unittest target_name)
   if(NOT LLVM_INCLUDE_TESTS)
     return()
   endif()
 
   cmake_parse_arguments(
     "LIBC_UNITTEST"
-    "" # No optional arguments
+    "NO_RUN_POSTBUILD" # Optional arguments
     "SUITE" # Single value arguments
-    "SRCS;HDRS;DEPENDS;COMPILE_OPTIONS" # Multi-value arguments
+    "SRCS;HDRS;DEPENDS;COMPILE_OPTIONS;LINK_OPTIONS" # Multi-value arguments
     "NO_LIBC_UNITTEST_TEST_MAIN"
     ${ARGN}
   )
   if(NOT LIBC_UNITTEST_SRCS)
     message(FATAL_ERROR "'add_libc_unittest' target requires a SRCS list of .cpp "
                         "files.")
   endif()
   if(NOT LIBC_UNITTEST_DEPENDS)
function(add_libc_unittest target_name)
   if(LIBC_UNITTEST_COMPILE_OPTIONS)
     target_compile_options(
       ${fq_target_name}
       PRIVATE ${LIBC_UNITTEST_COMPILE_OPTIONS}
     )
   endif()
 
   target_link_libraries(${fq_target_name} PRIVATE ${link_object_files})
+  if(LIBC_UNITTEST_LINK_OPTIONS)
+    target_link_options(
+      ${fq_target_name}
+      PRIVATE ${LIBC_UNITTEST_LINK_OPTIONS}
+    )
+  endif()
 
   set_target_properties(${fq_target_name}
     PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 
   add_dependencies(
     ${fq_target_name}
     ${fq_deps_list}
   )
 
   if(NO_LIBC_UNITTEST_TEST_MAIN)
     target_link_libraries(${fq_target_name} PRIVATE LibcUnitTest libc_test_utils)
   else()
     target_link_libraries(${fq_target_name} PRIVATE LibcUnitTest LibcUnitTestMain libc_test_utils)
   endif()
 
+  if(NOT LIBC_UNITTEST_NO_RUN_POSTBUILD)
     add_custom_command(
       TARGET ${fq_target_name}
       POST_BUILD
       COMMAND $<TARGET_FILE:${fq_target_name}>
     )
+  endif()
+
   if(LIBC_UNITTEST_SUITE)
     add_dependencies(
       ${LIBC_UNITTEST_SUITE}
       ${fq_target_name}
     )
   endif()
 endfunction(add_libc_unittest)
 

libc/test/src/math/exhaustive/CMakeLists.txt

 add_libc_exhaustive_testsuite(libc_math_exhaustive_tests)
 
+add_object_library(
+  exhaustive_test
+  HDRS
+    exhaustive_test.h
+  SRCS
+    exhaustive_test.cpp
+  DEPENDS
+    libc.src.__support.CPP.standalone_cpp
+)
+
 add_fp_unittest(
   sqrtf_test
   NEED_MPFR
   SUITE
     libc_math_exhaustive_tests
   SRCS
     sqrtf_test.cpp
   DEPENDS
add_fp_unittest(
   DEPENDS
     libc.include.math
     libc.src.math.expm1f
     libc.src.__support.FPUtil.fputil
 )
 
 add_fp_unittest(
   logf_test
+  NO_RUN_POSTBUILD
   NEED_MPFR
   SUITE
     libc_math_exhaustive_tests
   SRCS
     logf_test.cpp
   DEPENDS
+    .exhaustive_test
     libc.include.math
     libc.src.math.logf
     libc.src.__support.FPUtil.fputil
+  LINK_OPTIONS
+    -lpthread
 )

libc/test/src/math/exhaustive/exhaustive_test.h

+//===-- 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 "utils/UnitTest/Test.h"
+
+// To test exhaustively for inputs in the range [start, stop) in parallel:
+// 1. Inherit from LlvmLibcExhaustiveTest class
+// 2. Define a test method: void test(T, T)
+// 3. Assign the method pointer: check = static_cast<TestFunc>(&class::test)
+// 4. Call: test_full_range(start, stop, nthreads)
+template <typename T>
+struct LlvmLibcExhaustiveTest : public __llvm_libc::testing::Test {
+  // Test function signature
+  using TestFunc = void (LlvmLibcExhaustiveTest::*)(T, T);
+
+  // Break [start, stop) into `nthreads` subintervals and apply *check to each
+  // subinterval in parallel.
+  void test_full_range(T start, T stop, int nthreads);
+
+  // Pointer to the testing method to be used by `test_full_range`.
+  void (LlvmLibcExhaustiveTest::*check)(T, T);
+};

libc/test/src/math/exhaustive/exhaustive_test.cpp

+//===-- 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 <fenv.h>
+#include <functional>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include "exhaustive_test.h"
+#include "utils/UnitTest/Test.h"
+
+template <typename T>
+void LlvmLibcExhaustiveTest<T>::test_full_range(T start, T stop, int nthreads) {
+  std::vector<std::thread> thread_list(nthreads);
+  T increment = (stop - start - 1) / nthreads + 1;
+  T begin = start;
+  T end = start + increment - 1;
+  for (int i = 0; i < nthreads; ++i) {
+    thread_list.emplace_back([this, begin, end]() {
+      std::stringstream msg;
+      msg << "-- Testing from " << begin << " to " << end << " [0x" << std::hex
+          << begin << ", 0x" << end << ") ..." << std::endl;
+      std::cout << msg.str();
+      msg.str("");
+
+      (this->*check)(begin, end);
+
+      msg << "** Finished testing from " << std::dec << begin << " to " << end
+          << " [0x" << std::hex << begin << ", 0x" << end << ")" << std::endl;
+      std::cout << msg.str();
+    });
+    begin += increment;
+    end += increment;
+    if (end > stop)
+      end = stop;
+  }
+  for (auto &thread : thread_list) {
+    if (thread.joinable()) {
+      thread.join();
+    }
+  }
+}
+
+template void LlvmLibcExhaustiveTest<uint32_t>::test_full_range(uint32_t start,
+                                                                uint32_t stop,
+                                                                int nthreads);
+template void LlvmLibcExhaustiveTest<uint64_t>::test_full_range(uint64_t start,
+                                                                uint64_t stop,
+                                                                int nthreads);

libc/test/src/math/exhaustive/logf_test.cpp

 //===-- Exhaustive test for logf ------------------------------------------===//
 //
 // 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 "exhaustive_test.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/math/logf.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include "utils/UnitTest/FPMatcher.h"
-#include "utils/UnitTest/Test.h"
 
 using FPBits = __llvm_libc::fputil::FPBits<float>;
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
-TEST(LlvmLibcLogfExhaustiveTest, AllValues) {
-  uint32_t bits = 0U;
+struct LlvmLibcLogfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
+  template <mpfr::RoundingMode Rounding>
+  void test(uint32_t start, uint32_t stop) {
+    mpfr::ForceRoundingMode r(Rounding);
+    uint32_t bits = start;
     do {
       FPBits xbits(bits);
       float x = float(xbits);
-    EXPECT_MPFR_MATCH(mpfr::Operation::Log, x, __llvm_libc::logf(x), 0.5);
-  } while (bits++ < 0x7f7f'ffffU);
+      EXPECT_MPFR_MATCH(mpfr::Operation::Log, x, __llvm_libc::logf(x), 0.5,
+                        Rounding);
+    } while (bits++ < stop);
+  }
+};
+
+TEST_F(LlvmLibcLogfExhaustiveTest, RoundNearestTieToEven) {
+  check = static_cast<TestFunc>(
+      &LlvmLibcLogfExhaustiveTest::test<mpfr::RoundingMode::Nearest>);
+  test_full_range(/*start=*/0U, /*stop=*/0x7f80'0000U, /*nthreads=*/16);
+}
+
+TEST_F(LlvmLibcLogfExhaustiveTest, RoundUp) {
+  check = static_cast<TestFunc>(
+      &LlvmLibcLogfExhaustiveTest::test<mpfr::RoundingMode::Upward>);
+  test_full_range(/*start=*/0U, /*stop=*/0x7f80'0000U, /*nthreads=*/16);
+}
+
+TEST_F(LlvmLibcLogfExhaustiveTest, RoundDown) {
+  check = static_cast<TestFunc>(
+      &LlvmLibcLogfExhaustiveTest::test<mpfr::RoundingMode::Downward>);
+  test_full_range(/*start=*/0U, /*stop=*/0x7f80'0000U, /*nthreads=*/16);
+}
+
+TEST_F(LlvmLibcLogfExhaustiveTest, RoundTowardZero) {
+  check = static_cast<TestFunc>(
+      &LlvmLibcLogfExhaustiveTest::test<mpfr::RoundingMode::TowardZero>);
+  test_full_range(/*start=*/0U, /*stop=*/0x7f80'0000U, /*nthreads=*/16);
 }

libc/utils/MPFRWrapper/MPFRUtils.h

enum class Operation : int {
   // output.
   BeginTernaryOperationsSingleOuput,
   Fma,
   EndTernaryOperationsSingleOutput,
 };
 
 enum class RoundingMode : uint8_t { Upward, Downward, TowardZero, Nearest };
 
+int get_fe_rounding(RoundingMode);
+
+struct ForceRoundingMode {
+  ForceRoundingMode(RoundingMode);
+  ~ForceRoundingMode();
+
+  int old_rounding_mode;
+  int rounding_mode;
+};
+
 template <typename T> struct BinaryInput {
   static_assert(
       __llvm_libc::cpp::IsFloatingPointType<T>::Value,
       "Template parameter of BinaryInput must be a floating point type.");
 
   using Type = T;
   T x, y;
 };

libc/utils/MPFRWrapper/MPFRUtils.cpp

 //===-- Utils which wrap MPFR ---------------------------------------------===//
 //
 // 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 "MPFRUtils.h"
 
 #include "src/__support/CPP/StringView.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/architectures.h"
 #include "utils/UnitTest/FPMatcher.h"
 
 #include <cmath>
+#include <fenv.h>
 #include <memory>
+#include <sstream>
 #include <stdint.h>
 #include <string>
 
 #ifdef CUSTOM_MPFR_INCLUDER
 // Some downstream repos are monoliths carrying MPFR sources in their third
 // party directory. In such repos, including the MPFR header as
 // `#include <mpfr.h>` is either disallowed or not possible. If that is the
 // case, a file named `CustomMPFRIncluder.h` should be added through which the
case RoundingMode::TowardZero:
     return MPFR_RNDZ;
     break;
   case RoundingMode::Nearest:
     return MPFR_RNDN;
     break;
   }
 }
 
+int get_fe_rounding(RoundingMode mode) {
+  switch (mode) {
+  case RoundingMode::Upward:
+    return FE_UPWARD;
+    break;
+  case RoundingMode::Downward:
+    return FE_DOWNWARD;
+    break;
+  case RoundingMode::TowardZero:
+    return FE_TOWARDZERO;
+    break;
+  case RoundingMode::Nearest:
+    return FE_TONEAREST;
+    break;
+  }
+}
+
+ForceRoundingMode::ForceRoundingMode(RoundingMode mode) {
+  old_rounding_mode = fegetround();
+  rounding_mode = get_fe_rounding(mode);
+  if (old_rounding_mode != rounding_mode)
+    fesetround(rounding_mode);
+}
+
+ForceRoundingMode::~ForceRoundingMode() {
+  if (old_rounding_mode != rounding_mode)
+    fesetround(old_rounding_mode);
+}
+
 class MPFRNumber {
   // A precision value which allows sufficiently large additional
   // precision even compared to quad-precision floating point values.
   unsigned int mpfr_precision;
   mpfr_rnd_t mpfr_rounding;
 
   mpfr_t value;
 

 template <typename T>
 void explain_unary_operation_single_output_error(Operation op, T input,
                                                  T matchValue,
                                                  RoundingMode rounding,
                                                  testutils::StreamWrapper &OS) {
   MPFRNumber mpfrInput(input);
   MPFRNumber mpfr_result = unary_operation(op, input, rounding);
   MPFRNumber mpfrMatchValue(matchValue);
-  OS << "Match value not within tolerance value of MPFR result:\n"
+  std::stringstream ss;
+  ss << "Match value not within tolerance value of MPFR result:\n"
      << "  Input decimal: " << mpfrInput.str() << '\n';
-  __llvm_libc::fputil::testing::describeValue("     Input bits: ", input, OS);
-  OS << '\n' << "  Match decimal: " << mpfrMatchValue.str() << '\n';
+  __llvm_libc::fputil::testing::describeValue("     Input bits: ", input, ss);
+  ss << '\n' << "  Match decimal: " << mpfrMatchValue.str() << '\n';
   __llvm_libc::fputil::testing::describeValue("     Match bits: ", matchValue,
-                                              OS);
-  OS << '\n' << "    MPFR result: " << mpfr_result.str() << '\n';
+                                              ss);
+  ss << '\n' << "    MPFR result: " << mpfr_result.str() << '\n';
   __llvm_libc::fputil::testing::describeValue(
-      "   MPFR rounded: ", mpfr_result.as<T>(), OS);
-  OS << '\n';
-  OS << "      ULP error: " << std::to_string(mpfr_result.ulp(matchValue))
+      "   MPFR rounded: ", mpfr_result.as<T>(), ss);
+  ss << '\n';
+  ss << "      ULP error: " << std::to_string(mpfr_result.ulp(matchValue))
      << '\n';
+  OS << ss.str();
 }
 
 template void explain_unary_operation_single_output_error<float>(
     Operation op, float, float, RoundingMode, testutils::StreamWrapper &);
 template void explain_unary_operation_single_output_error<double>(
     Operation op, double, double, RoundingMode, testutils::StreamWrapper &);
 template void explain_unary_operation_single_output_error<long double>(
     Operation op, long double, long double, RoundingMode,
     testutils::StreamWrapper &);
 
 template <typename T>
 void explain_unary_operation_two_outputs_error(
     Operation op, T input, const BinaryOutput<T> &libc_result,
     RoundingMode rounding, testutils::StreamWrapper &OS) {
   MPFRNumber mpfrInput(input);
   int mpfrIntResult;
   MPFRNumber mpfr_result =
       unary_operation_two_outputs(op, input, mpfrIntResult, rounding);
+  std::stringstream ss;
 
   if (mpfrIntResult != libc_result.i) {
-    OS << "MPFR integral result: " << mpfrIntResult << '\n'
+    ss << "MPFR integral result: " << mpfrIntResult << '\n'
        << "Libc integral result: " << libc_result.i << '\n';
   } else {
-    OS << "Integral result from libc matches integral result from MPFR.\n";
+    ss << "Integral result from libc matches integral result from MPFR.\n";
   }
 
   MPFRNumber mpfrMatchValue(libc_result.f);
-  OS << "Libc floating point result is not within tolerance value of the MPFR "
+  ss << "Libc floating point result is not within tolerance value of the MPFR "
      << "result.\n\n";
 
-  OS << "            Input decimal: " << mpfrInput.str() << "\n\n";
+  ss << "            Input decimal: " << mpfrInput.str() << "\n\n";
 
-  OS << "Libc floating point value: " << mpfrMatchValue.str() << '\n';
+  ss << "Libc floating point value: " << mpfrMatchValue.str() << '\n';
   __llvm_libc::fputil::testing::describeValue(
-      " Libc floating point bits: ", libc_result.f, OS);
-  OS << "\n\n";
+      " Libc floating point bits: ", libc_result.f, ss);
+  ss << "\n\n";
 
-  OS << "              MPFR result: " << mpfr_result.str() << '\n';
+  ss << "              MPFR result: " << mpfr_result.str() << '\n';
   __llvm_libc::fputil::testing::describeValue(
-      "             MPFR rounded: ", mpfr_result.as<T>(), OS);
-  OS << '\n'
+      "             MPFR rounded: ", mpfr_result.as<T>(), ss);
+  ss << '\n'
      << "                ULP error: "
      << std::to_string(mpfr_result.ulp(libc_result.f)) << '\n';
+  OS << ss.str();
 }
 
 template void explain_unary_operation_two_outputs_error<float>(
     Operation, float, const BinaryOutput<float> &, RoundingMode,
     testutils::StreamWrapper &);
 template void explain_unary_operation_two_outputs_error<double>(
     Operation, double, const BinaryOutput<double> &, RoundingMode,
     testutils::StreamWrapper &);
 template void explain_unary_operation_two_outputs_error<long double>(
     Operation, long double, const BinaryOutput<long double> &, RoundingMode,
     testutils::StreamWrapper &);
 
 template <typename T>
 void explain_binary_operation_two_outputs_error(
     Operation op, const BinaryInput<T> &input,
     const BinaryOutput<T> &libc_result, RoundingMode rounding,
     testutils::StreamWrapper &OS) {
   MPFRNumber mpfrX(input.x);
   MPFRNumber mpfrY(input.y);
   int mpfrIntResult;
   MPFRNumber mpfr_result = binary_operation_two_outputs(
       op, input.x, input.y, mpfrIntResult, rounding);
   MPFRNumber mpfrMatchValue(libc_result.f);
+  std::stringstream ss;
 
-  OS << "Input decimal: x: " << mpfrX.str() << " y: " << mpfrY.str() << '\n'
+  ss << "Input decimal: x: " << mpfrX.str() << " y: " << mpfrY.str() << '\n'
      << "MPFR integral result: " << mpfrIntResult << '\n'
      << "Libc integral result: " << libc_result.i << '\n'
      << "Libc floating point result: " << mpfrMatchValue.str() << '\n'
      << "               MPFR result: " << mpfr_result.str() << '\n';
   __llvm_libc::fputil::testing::describeValue(
-      "Libc floating point result bits: ", libc_result.f, OS);
+      "Libc floating point result bits: ", libc_result.f, ss);
   __llvm_libc::fputil::testing::describeValue(
-      "              MPFR rounded bits: ", mpfr_result.as<T>(), OS);
-  OS << "ULP error: " << std::to_string(mpfr_result.ulp(libc_result.f)) << '\n';
+      "              MPFR rounded bits: ", mpfr_result.as<T>(), ss);
+  ss << "ULP error: " << std::to_string(mpfr_result.ulp(libc_result.f)) << '\n';
+  OS << ss.str();
 }
 
 template void explain_binary_operation_two_outputs_error<float>(
     Operation, const BinaryInput<float> &, const BinaryOutput<float> &,
     RoundingMode, testutils::StreamWrapper &);
 template void explain_binary_operation_two_outputs_error<double>(
     Operation, const BinaryInput<double> &, const BinaryOutput<double> &,
     RoundingMode, testutils::StreamWrapper &);
void explain_binary_operation_one_output_error(Operation op,
                                                testutils::StreamWrapper &OS) {
   MPFRNumber mpfrX(input.x);
   MPFRNumber mpfrY(input.y);
   FPBits<T> xbits(input.x);
   FPBits<T> ybits(input.y);
   MPFRNumber mpfr_result =
       binary_operation_one_output(op, input.x, input.y, rounding);
   MPFRNumber mpfrMatchValue(libc_result);
+  std::stringstream ss;
 
-  OS << "Input decimal: x: " << mpfrX.str() << " y: " << mpfrY.str() << '\n';
+  ss << "Input decimal: x: " << mpfrX.str() << " y: " << mpfrY.str() << '\n';
   __llvm_libc::fputil::testing::describeValue("First input bits: ", input.x,
-                                              OS);
+                                              ss);
   __llvm_libc::fputil::testing::describeValue("Second input bits: ", input.y,
-                                              OS);
+                                              ss);
 
-  OS << "Libc result: " << mpfrMatchValue.str() << '\n'
+  ss << "Libc result: " << mpfrMatchValue.str() << '\n'
      << "MPFR result: " << mpfr_result.str() << '\n';
   __llvm_libc::fputil::testing::describeValue(
-      "Libc floating point result bits: ", libc_result, OS);
+      "Libc floating point result bits: ", libc_result, ss);
   __llvm_libc::fputil::testing::describeValue(
-      "              MPFR rounded bits: ", mpfr_result.as<T>(), OS);
-  OS << "ULP error: " << std::to_string(mpfr_result.ulp(libc_result)) << '\n';
+      "              MPFR rounded bits: ", mpfr_result.as<T>(), ss);
+  ss << "ULP error: " << std::to_string(mpfr_result.ulp(libc_result)) << '\n';
+  OS << ss.str();
 }
 
 template void explain_binary_operation_one_output_error<float>(
     Operation, const BinaryInput<float> &, float, RoundingMode,
     testutils::StreamWrapper &);
 template void explain_binary_operation_one_output_error<double>(
     Operation, const BinaryInput<double> &, double, RoundingMode,
     testutils::StreamWrapper &);
void explain_ternary_operation_one_output_error(Operation op,
   MPFRNumber mpfrY(input.y, Precision<T>::VALUE);
   MPFRNumber mpfrZ(input.z, Precision<T>::VALUE);
   FPBits<T> xbits(input.x);
   FPBits<T> ybits(input.y);
   FPBits<T> zbits(input.z);
   MPFRNumber mpfr_result =
       ternary_operation_one_output(op, input.x, input.y, input.z, rounding);
   MPFRNumber mpfrMatchValue(libc_result);
+  std::stringstream ss;
 
-  OS << "Input decimal: x: " << mpfrX.str() << " y: " << mpfrY.str()
+  ss << "Input decimal: x: " << mpfrX.str() << " y: " << mpfrY.str()
      << " z: " << mpfrZ.str() << '\n';
   __llvm_libc::fputil::testing::describeValue("First input bits: ", input.x,
-                                              OS);
+                                              ss);
   __llvm_libc::fputil::testing::describeValue("Second input bits: ", input.y,
-                                              OS);
+                                              ss);
   __llvm_libc::fputil::testing::describeValue("Third input bits: ", input.z,
-                                              OS);
+                                              ss);
 
-  OS << "Libc result: " << mpfrMatchValue.str() << '\n'
+  ss << "Libc result: " << mpfrMatchValue.str() << '\n'
      << "MPFR result: " << mpfr_result.str() << '\n';
   __llvm_libc::fputil::testing::describeValue(
-      "Libc floating point result bits: ", libc_result, OS);
+      "Libc floating point result bits: ", libc_result, ss);
   __llvm_libc::fputil::testing::describeValue(
-      "              MPFR rounded bits: ", mpfr_result.as<T>(), OS);
-  OS << "ULP error: " << std::to_string(mpfr_result.ulp(libc_result)) << '\n';
+      "              MPFR rounded bits: ", mpfr_result.as<T>(), ss);
+  ss << "ULP error: " << std::to_string(mpfr_result.ulp(libc_result)) << '\n';
+  OS << ss.str();
 }
 
 template void explain_ternary_operation_one_output_error<float>(
     Operation, const TernaryInput<float> &, float, RoundingMode,
     testutils::StreamWrapper &);
 template void explain_ternary_operation_one_output_error<double>(
     Operation, const TernaryInput<double> &, double, RoundingMode,
     testutils::StreamWrapper &);
 template void explain_ternary_operation_one_output_error<long double>(
     Operation, const TernaryInput<long double> &, long double, RoundingMode,
     testutils::StreamWrapper &);
 
 template <typename T>
 bool compare_unary_operation_single_output(Operation op, T input, T libc_result,
                                            double ulp_error,
                                            RoundingMode rounding) {
   // If the ulp error is exactly 0.5 (i.e a tie), we would check that the result
   // is rounded to the nearest even.
   MPFRNumber mpfr_result = unary_operation(op, input, rounding);
   double ulp = mpfr_result.ulp(libc_result);
-  bool bits_are_even = ((FPBits<T>(libc_result).uintval() & 1) == 0);
   return (ulp < ulp_error) ||
-         ((ulp == ulp_error) && ((ulp != 0.5) || bits_are_even));
+         ((ulp == ulp_error) &&
+          ((ulp != 0.5) || mpfr_result.as<T>() == libc_result));
 }
 
 template bool compare_unary_operation_single_output<float>(Operation, float,
                                                            float, double,
                                                            RoundingMode);
 template bool compare_unary_operation_single_output<double>(Operation, double,
                                                             double, double,
                                                             RoundingMode);

 bool compare_binary_operation_one_output(Operation op,
                                          const BinaryInput<T> &input,
                                          T libc_result, double ulp_error,
                                          RoundingMode rounding) {
   MPFRNumber mpfr_result =
       binary_operation_one_output(op, input.x, input.y, rounding);
   double ulp = mpfr_result.ulp(libc_result);
 
-  bool bits_are_even = ((FPBits<T>(libc_result).uintval() & 1) == 0);
   return (ulp < ulp_error) ||
-         ((ulp == ulp_error) && ((ulp != 0.5) || bits_are_even));
+         ((ulp == ulp_error) &&
+          ((ulp != 0.5) || mpfr_result.as<T>() == libc_result));
 }
 
 template bool compare_binary_operation_one_output<float>(
     Operation, const BinaryInput<float> &, float, double, RoundingMode);
 template bool compare_binary_operation_one_output<double>(
     Operation, const BinaryInput<double> &, double, double, RoundingMode);
 template bool compare_binary_operation_one_output<long double>(
     Operation, const BinaryInput<long double> &, long double, double,
     RoundingMode);
 
 template <typename T>
 bool compare_ternary_operation_one_output(Operation op,
                                           const TernaryInput<T> &input,
                                           T libc_result, double ulp_error,
                                           RoundingMode rounding) {
   MPFRNumber mpfr_result =
       ternary_operation_one_output(op, input.x, input.y, input.z, rounding);
   double ulp = mpfr_result.ulp(libc_result);
 
-  bool bits_are_even = ((FPBits<T>(libc_result).uintval() & 1) == 0);
   return (ulp < ulp_error) ||
-         ((ulp == ulp_error) && ((ulp != 0.5) || bits_are_even));
+         ((ulp == ulp_error) &&
+          ((ulp != 0.5) || mpfr_result.as<T>() == libc_result));
 }
 
 template bool compare_ternary_operation_one_output<float>(
     Operation, const TernaryInput<float> &, float, double, RoundingMode);
 template bool compare_ternary_operation_one_output<double>(
     Operation, const TernaryInput<double> &, double, double, RoundingMode);
 template bool compare_ternary_operation_one_output<long double>(
     Operation, const TernaryInput<long double> &, long double, double,

libc/utils/UnitTest/FPMatcher.h

 #include "src/__support/FPUtil/FPBits.h"
 
 #include "utils/UnitTest/Test.h"
 
 namespace __llvm_libc {
 namespace fputil {
 namespace testing {
 
-template <typename ValType>
+template <typename ValType, typename StreamType>
 cpp::EnableIfType<cpp::IsFloatingPointType<ValType>::Value, void>
-describeValue(const char *label, ValType value,
-              testutils::StreamWrapper &stream);
+describeValue(const char *label, ValType value, StreamType &stream);
 
 template <typename T, __llvm_libc::testing::TestCondition Condition>
 class FPMatcher : public __llvm_libc::testing::Matcher<T> {
   static_assert(__llvm_libc::cpp::IsFloatingPointType<T>::Value,
                 "FPMatcher can only be used with floating point values.");
   static_assert(Condition == __llvm_libc::testing::Cond_EQ ||
                     Condition == __llvm_libc::testing::Cond_NE,
                 "Unsupported FPMathcer test condition.");

libc/utils/UnitTest/FPMatcher.cpp

 //===-- TestMatchers.cpp ----------------------------------------*- 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 "FPMatcher.h"
 
 #include "src/__support/FPUtil/FPBits.h"
 
+#include <sstream>
 #include <string>
 
 namespace __llvm_libc {
 namespace fputil {
 namespace testing {
 
 // Return the first N hex digits of an integer as a string in upper case.
 template <typename T>
 cpp::EnableIfType<cpp::IsIntegral<T>::Value, std::string>
 uintToHex(T X, size_t Length = sizeof(T) * 2) {
   std::string s(Length, '0');
 
   for (auto it = s.rbegin(), end = s.rend(); it != end; ++it, X >>= 4) {
     unsigned char Mod = static_cast<unsigned char>(X) & 15;
     *it = (Mod < 10 ? '0' + Mod : 'a' + Mod - 10);
   }
 
   return s;
 }
 
-template <typename ValType>
+template <typename ValType, typename StreamType>
 cpp::EnableIfType<cpp::IsFloatingPointType<ValType>::Value, void>
-describeValue(const char *label, ValType value,
-              testutils::StreamWrapper &stream) {
+describeValue(const char *label, ValType value, StreamType &stream) {
   stream << label;
 
   FPBits<ValType> bits(value);
   if (bits.is_nan()) {
     stream << "(NaN)";
   } else if (bits.is_inf()) {
     if (bits.get_sign())
       stream << "(-Infinity)";
     else
       stream << "(+Infinity)";
   } else {
     constexpr int exponentWidthInHex =
         (fputil::ExponentWidth<ValType>::VALUE - 1) / 4 + 1;
     constexpr int mantissaWidthInHex =
         (fputil::MantissaWidth<ValType>::VALUE - 1) / 4 + 1;
+    constexpr int bitsWidthInHex =
+        sizeof(typename fputil::FPBits<ValType>::UIntType) * 2;
 
-    stream << "Sign: " << (bits.get_sign() ? '1' : '0') << ", "
-           << "Exponent: 0x"
+    stream << "0x"
+           << uintToHex<typename fputil::FPBits<ValType>::UIntType>(
+                  bits.uintval(), bitsWidthInHex)
+           << ", (S | E | M) = (" << (bits.get_sign() ? '1' : '0') << " | 0x"
            << uintToHex<uint16_t>(bits.get_unbiased_exponent(),
                                   exponentWidthInHex)
-           << ", "
-           << "Mantissa: 0x"
+           << " | 0x"
            << uintToHex<typename fputil::FPBits<ValType>::UIntType>(
-                  bits.get_mantissa(), mantissaWidthInHex);
+                  bits.get_mantissa(), mantissaWidthInHex)
+           << ")";
   }
 
   stream << '\n';
 }
 
 template void describeValue<float>(const char *, float,
                                    testutils::StreamWrapper &);
 template void describeValue<double>(const char *, double,
                                     testutils::StreamWrapper &);
 template void describeValue<long double>(const char *, long double,
                                          testutils::StreamWrapper &);
 
+template void describeValue<float>(const char *, float, std::stringstream &);
+template void describeValue<double>(const char *, double, std::stringstream &);
+template void describeValue<long double>(const char *, long double,
+                                         std::stringstream &);
+
 } // namespace testing
 } // namespace fputil
 } // namespace __llvm_libc