[libc][NFC] Remove use of StreamWrapper from math differential tests.

[sivachandra]

Summary

Along the way, the utility Timer has been moved to the math differential
test directory.

libc/test/src/math/differential_testing/BinaryOpSingleOutputDiff.h

 //===-- Common utility class for differential analysis --------------------===//
 //
 // 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 "utils/testutils/StreamWrapper.h"
-#include "utils/testutils/Timer.h"
+#include "test/src/math/differential_testing/Timer.h"
+
+#include <fstream>
 
 namespace __llvm_libc {
 namespace testing {
 
 template <typename T> class BinaryOpSingleOutputDiff {
   using FPBits = fputil::FPBits<T>;
   using UIntType = typename FPBits::UIntType;
   static constexpr UIntType MSBIT = UIntType(1) << (8 * sizeof(UIntType) - 1);
   static constexpr UIntType UINTMAX = (MSBIT - 1) + MSBIT;
 
 public:
   typedef T Func(T, T);
 
   static uint64_t run_diff_in_range(Func myFunc, Func otherFunc,
                                     UIntType startingBit, UIntType endingBit,
-                                    UIntType N,
-                                    testutils::OutputFileStream &log) {
+                                    UIntType N, std::ofstream &log) {
     uint64_t result = 0;
     if (endingBit < startingBit) {
       return result;
     }
 
     UIntType step = (endingBit - startingBit) / N;
     for (UIntType bitsX = startingBit, bitsY = endingBit;;
          bitsX += step, bitsY -= step) {
for (UIntType bitsX = startingBit, bitsY = endingBit;;
         break;
       }
     }
     return result;
   }
 
   static void run_perf_in_range(Func myFunc, Func otherFunc,
                                 UIntType startingBit, UIntType endingBit,
-                                UIntType N, testutils::OutputFileStream &log) {
+                                UIntType N, std::ofstream &log) {
     auto runner = [=](Func func) {
       volatile T result;
       if (endingBit < startingBit) {
         return;
       }
 
       UIntType step = (endingBit - startingBit) / N;
       for (UIntType bitsX = startingBit, bitsY = endingBit;;
static void run_perf_in_range(Func myFunc, Func otherFunc,
     log << "     Ops per second  : "
         << static_cast<uint64_t>(1'000'000'000.0 / other_average) << " op/s \n";
 
     log << "-- Average runtime ratio --\n";
     log << "     Mine / Other's  : " << my_average / other_average << " \n";
   }
 
   static void run_perf(Func myFunc, Func otherFunc, const char *logFile) {
-    testutils::OutputFileStream log(logFile);
+    std::ofstream log(logFile);
     log << " Performance tests with inputs in denormal range:\n";
     run_perf_in_range(myFunc, otherFunc, /* startingBit= */ UIntType(0),
                       /* endingBit= */ FPBits::MAX_SUBNORMAL, 1'000'001, log);
     log << "\n Performance tests with inputs in normal range:\n";
     run_perf_in_range(myFunc, otherFunc, /* startingBit= */ FPBits::MIN_NORMAL,
                       /* endingBit= */ FPBits::MAX_NORMAL, 100'000'001, log);
     log << "\n Performance tests with inputs in normal range with exponents "
            "close to each other:\n";
     run_perf_in_range(
         myFunc, otherFunc, /* startingBit= */ FPBits(T(0x1.0p-10)).uintval(),
         /* endingBit= */ FPBits(T(0x1.0p+10)).uintval(), 10'000'001, log);
   }
 
   static void run_diff(Func myFunc, Func otherFunc, const char *logFile) {
     uint64_t diffCount = 0;
-    testutils::OutputFileStream log(logFile);
+    std::ofstream log(logFile);
     log << " Diff tests with inputs in denormal range:\n";
     diffCount += run_diff_in_range(
         myFunc, otherFunc, /* startingBit= */ UIntType(0),
         /* endingBit= */ FPBits::MAX_SUBNORMAL, 1'000'001, log);
     log << "\n Diff tests with inputs in normal range:\n";
     diffCount += run_diff_in_range(
         myFunc, otherFunc, /* startingBit= */ FPBits::MIN_NORMAL,
         /* endingBit= */ FPBits::MAX_NORMAL, 100'000'001, log);

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

+add_library(
+  libc_diff_test_utils
+  Timer.cpp
+  Timer.h
+)
+
+# A convenience target to build all differential tests.
+add_custom_target(libc-math-differential-tests)
 
 function(add_diff_binary target_name)
   cmake_parse_arguments(
     "DIFF"
     "" # No optional arguments
     "SUITE;CXX_STANDARD" # Single value arguments
     "SRCS;HDRS;DEPENDS;COMPILE_OPTIONS" # Multi-value arguments
     ${ARGN}
add_executable(
     EXCLUDE_FROM_ALL
     ${DIFF_SRCS}
     ${DIFF_HDRS}
   )
   target_include_directories(
     ${fq_target_name}
     PRIVATE
       ${LIBC_SOURCE_DIR}
-      ${LIBC_BUILD_DIR}
-      ${LIBC_BUILD_DIR}/include
   )
   if(DIFF_COMPILE_OPTIONS)
     target_compile_options(
       ${fq_target_name}
       PRIVATE ${DIFF_COMPILE_OPTIONS}
     )
   endif()
 
   target_link_libraries(
       ${fq_target_name}
-      PRIVATE ${link_object_files} libc_test_utils)
+      PRIVATE ${link_object_files} libc_test_utils libc_diff_test_utils)
 
   set_target_properties(${fq_target_name}
     PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
   
   if(DIFF_CXX_STANDARD)
     set_target_properties(
       ${fq_target_name}
       PROPERTIES
         CXX_STANDARD ${DIFF_CXX_STANDARD}
     )
   endif()
 
   add_dependencies(
     ${fq_target_name}
     libc.src.__support.FPUtil.fp_bits
     ${fq_deps_list}
   )
+  add_dependencies(libc-math-differential-tests ${fq_target_name})
 endfunction()
 
 add_header_library(
   single_input_single_output_diff
   HDRS
     SingleInputSingleOutputDiff.h
 )
 

libc/test/src/math/differential_testing/SingleInputSingleOutputDiff.h

 //===-- Common utility class for differential analysis --------------------===//
 //
 // 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 "utils/testutils/StreamWrapper.h"
-#include "utils/testutils/Timer.h"
+#include "test/src/math/differential_testing/Timer.h"
+
+#include <fstream>
 
 namespace __llvm_libc {
 namespace testing {
 
 template <typename T> class SingleInputSingleOutputDiff {
   using FPBits = fputil::FPBits<T>;
   using UIntType = typename FPBits::UIntType;
   static constexpr UIntType MSBit = UIntType(1) << (8 * sizeof(UIntType) - 1);
   static constexpr UIntType UIntMax = (MSBit - 1) + MSBit;
 
 public:
   typedef T Func(T);
 
   static void runDiff(Func myFunc, Func otherFunc, const char *logFile) {
     UIntType diffCount = 0;
-    testutils::OutputFileStream log(logFile);
+    std::ofstream log(logFile);
     log << "Starting diff for values from 0 to " << UIntMax << '\n'
         << "Only differing results will be logged.\n\n";
     for (UIntType bits = 0;; ++bits) {
       T x = T(FPBits(bits));
       T myResult = myFunc(x);
       T otherResult = otherFunc(x);
       UIntType myBits = FPBits(myResult).uintval();
       UIntType otherBits = FPBits(otherResult).uintval();
       if (myBits != otherBits) {
         ++diffCount;
         log << "       Input: " << bits << " (" << x << ")\n"
             << "   My result: " << myBits << " (" << myResult << ")\n"
             << "Other result: " << otherBits << " (" << otherResult << ")\n"
             << '\n';
       }
       if (bits == UIntMax)
         break;
     }
     log << "Total number of differing results: " << diffCount << '\n';
   }
 
   static void runPerfInRange(Func myFunc, Func otherFunc, UIntType startingBit,
-                             UIntType endingBit,
-                             testutils::OutputFileStream &log) {
+                             UIntType endingBit, std::ofstream &log) {
     auto runner = [=](Func func) {
       volatile T result;
       for (UIntType bits = startingBit;; ++bits) {
         T x = T(FPBits(bits));
         result = func(x);
         if (bits == endingBit)
           break;
       }
static void runPerfInRange(Func myFunc, Func otherFunc, UIntType startingBit,
     log << "     Ops per second  : "
         << static_cast<uint64_t>(1'000'000'000.0 / otherAverage) << " op/s \n";
 
     log << "-- Average runtime ratio --\n";
     log << "     Mine / Other's  : " << myAverage / otherAverage << " \n";
   }
 
   static void runPerf(Func myFunc, Func otherFunc, const char *logFile) {
-    testutils::OutputFileStream log(logFile);
+    std::ofstream log(logFile);
     log << " Performance tests with inputs in denormal range:\n";
     runPerfInRange(myFunc, otherFunc, /* startingBit= */ UIntType(0),
                    /* endingBit= */ FPBits::MAX_SUBNORMAL, log);
     log << "\n Performance tests with inputs in normal range:\n";
     runPerfInRange(myFunc, otherFunc, /* startingBit= */ FPBits::MIN_NORMAL,
                    /* endingBit= */ FPBits::MAX_NORMAL, log);
   }
 };

libc/test/src/math/differential_testing/Timer.h

 //===-- Timer.h -------------------------------------------------*- 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_UTILS_TESTUTILS_TIMER_H
 #define LLVM_LIBC_UTILS_TESTUTILS_TIMER_H
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace testing {
 
 class Timer {
   void *Impl;
 
 public:
   Timer();
   ~Timer();
 
   void start();
   void stop();
 
   uint64_t nanoseconds() const;
 };
 
 } // namespace testing
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_UTILS_TESTUTILS_TIMER_H

libc/test/src/math/differential_testing/Timer.cpp

 //===-- Timer.cpp --------------------------------------------------------===//
 //
 // 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 "Timer.h"
 
 #include <chrono>
 #include <fstream>
 
 namespace __llvm_libc {
 namespace testing {
 
 struct TimerImplementation {
   std::chrono::high_resolution_clock::time_point Start;
   std::chrono::high_resolution_clock::time_point End;
 };
 
 Timer::Timer() : Impl(new TimerImplementation) {}
 
 Timer::~Timer() { delete reinterpret_cast<TimerImplementation *>(Impl); }
 
 void Timer::start() {
   auto T = reinterpret_cast<TimerImplementation *>(Impl);
   T->Start = std::chrono::high_resolution_clock::now();
 }
 
 void Timer::stop() {
   auto T = reinterpret_cast<TimerImplementation *>(Impl);
   T->End = std::chrono::high_resolution_clock::now();
 }
 
 uint64_t Timer::nanoseconds() const {
   auto T = reinterpret_cast<TimerImplementation *>(Impl);
   return std::chrono::nanoseconds(T->End - T->Start).count();
 }
 
 } // namespace testing
 } // namespace __llvm_libc

libc/utils/testutils/CMakeLists.txt

 if(CMAKE_HOST_UNIX)
   set(EFFile ExecuteFunctionUnix.cpp)
   set(FDReaderFile FDReaderUnix.cpp)
 endif()
 
 add_library(
   libc_test_utils
   RandUtils.cpp
   RandUtils.h
   StreamWrapper.cpp
   StreamWrapper.h
   ${EFFile}
   ExecuteFunction.h
   ${FDReaderFile}
   FDReader.h
-  Timer.h
-  Timer.cpp
   RoundingModeUtils.cpp
 )