Add epsilon comparison for floating point (#217)

Change BufferFuzzy to 'BufferFloatULP' and 'BufferFloatEpsilon' 
Implemented BufferFloatEpsilon for 16, 32, and 64 bit floating point.
Add tests
Closes #216

Author: spall

README.md

@@ -80,7 +80,7 @@ Buffers:
     Data: [ 0x1, 0x2 ]
 Results: # Using Result can verify test values without filecheck
   - Result: Test1
-    Rule: BufferFuzzy # Rule which can be used to compare Float Buffers; They are compared within a ULP range
+    Rule: BufferFloatULP # Rule which can be used to compare Float Buffers; They are compared within a ULP range
     ULPT: 1 # ULP to use
     DenormMode: Any # if DenormMode Field is not Specified, 'Any' is the default; FTZ and Preserve are the other options.
     Actual: Out1 # First buffer to compare
@@ -89,6 +89,11 @@ Results: # Using Result can verify test values without filecheck
     Rule: BufferExact # Compares Two Buffers for == equality between each value elementwise
     Actual: Out1
     Expected: Expected1
+  - Result: Test3
+    Rule: BufferFloatEpsilon # Rule which can be used to compare Float Buffers; They are compared within an epsilon difference
+    Epsilon: 0.0008
+    Actual: Out1
+    Expected: Expected1
 DescriptorSets:
   - Resources:
     - Name: Constants

include/Support/Pipeline.h

@@ -25,7 +25,7 @@ namespace offloadtest {
 
 enum class Stages { Compute };
 
-enum class Rule { BufferExact, BufferFuzzy };
+enum class Rule { BufferExact, BufferFloatULP, BufferFloatEpsilon };
 
 enum class DenormMode { Any, FTZ, Preserve };
 
@@ -123,6 +123,7 @@ struct Result {
   Buffer *ExpectedPtr = nullptr;
   DenormMode DM = DenormMode::Any;
   unsigned ULPT; // ULP Tolerance
+  double Epsilon;
 };
 
 struct Resource {
@@ -316,7 +317,8 @@ template <> struct ScalarEnumerationTraits<offloadtest::Rule> {
   static void enumeration(IO &I, offloadtest::Rule &V) {
 #define ENUM_CASE(Val) I.enumCase(V, #Val, offloadtest::Rule::Val)
     ENUM_CASE(BufferExact);
-    ENUM_CASE(BufferFuzzy);
+    ENUM_CASE(BufferFloatULP);
+    ENUM_CASE(BufferFloatEpsilon);
 #undef ENUM_CASE
   }
 };

lib/Support/Check.cpp

@@ -10,6 +10,8 @@
 //===----------------------------------------------------------------------===//
 
 #include "Support/Check.h"
+#include "llvm/ADT/APFloat.h"
+#include "llvm/ADT/APInt.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cmath>
@@ -18,6 +20,16 @@ constexpr uint16_t Float16BitSign = 0x8000;
 constexpr uint16_t Float16BitExp = 0x7c00;
 constexpr uint16_t Float16BitMantissa = 0x03ff;
 
+static float convertFloat16ToFloat(const uint16_t F) {
+  const llvm::APInt API(16, F);
+  llvm::detail::IEEEFloat IEF(llvm::APFloat::IEEEhalf(), API);
+  bool LostInfo;
+  // rounding mode should not matter since we are up converting
+  IEF.convert(llvm::APFloat::IEEEsingle(),
+              llvm::APFloatBase::rmNearestTiesToEven, &LostInfo);
+  return IEF.convertToFloat();
+}
+
 // limited to float, double, and long double
 template <typename T> static bool isDenorm(T F) {
   return std::fpclassify(F) == FP_SUBNORMAL;
@@ -28,6 +40,23 @@ static bool isFloat16NAN(uint16_t Val) {
          (Val & Float16BitMantissa) != 0;
 }
 
+static bool compareDoubleEpsilon(const double &FSrc, const double &FRef,
+                                 double Epsilon, offloadtest::DenormMode DM) {
+  if (FSrc == FRef)
+    return true;
+  if (std::isnan(FSrc) || std::isnan(FRef))
+    return std::isnan(FRef) && std::isnan(FSrc);
+  if (DM == offloadtest::DenormMode::Any) {
+    // If denorm expected, output can be sign preserved zero. Otherwise output
+    // should pass the regular ulp testing.
+    if (isDenorm(FRef) && FSrc == 0 && std::signbit(FSrc) == std::signbit(FRef))
+      return true;
+  }
+  // For FTZ or Preserve mode, we should get the expected number within
+  // epsilon for any operation
+  return std::abs(FSrc - FRef) < Epsilon;
+}
+
 static bool compareDoubleULP(const double &FSrc, const double &FRef,
                              unsigned ULPTolerance,
                              offloadtest::DenormMode DM) {
@@ -48,6 +77,24 @@ static bool compareDoubleULP(const double &FSrc, const double &FRef,
   return AbsDiff <= ULPTolerance;
 }
 
+static bool compareFloatEpsilon(const float &FSrc, const float &FRef,
+                                float Epsilon, offloadtest::DenormMode DM) {
+  if (FSrc == FRef)
+    return true;
+  if (std::isnan(FSrc) || std::isnan(FRef))
+    return std::isnan(FRef) && std::isnan(FSrc);
+  if (DM == offloadtest::DenormMode::Any) {
+    // If denorm expected, output can be sign preserved zero. Otherwise output
+    // should pass the regular ulp testing.
+    if (isDenorm(FRef) && FSrc == 0 && std::signbit(FSrc) == std::signbit(FRef))
+      return true;
+  }
+
+  // For FTZ or Preserve mode, we should get the expected number within
+  // epsilon for any operation
+  return std::abs(FSrc - FRef) < Epsilon;
+}
+
 static bool compareFloatULP(const float &FSrc, const float &FRef,
                             unsigned ULPTolerance, offloadtest::DenormMode DM) {
   if (FSrc == FRef)
@@ -67,6 +114,21 @@ static bool compareFloatULP(const float &FSrc, const float &FRef,
   return AbsDiff <= ULPTolerance;
 }
 
+static bool compareFloat16Epsilon(const uint16_t &FSrc, const uint16_t &FRef,
+                                  float Epsilon) {
+  // Treat +0 and -0 as equal
+  if ((FSrc & ~Float16BitSign) == 0 && (FRef & ~Float16BitSign) == 0)
+    return true;
+  if (FSrc == FRef)
+    return true;
+  if (isFloat16NAN(FSrc) || isFloat16NAN(FRef))
+    return isFloat16NAN(FRef) && isFloat16NAN(FSrc);
+
+  const float FSrc32 = convertFloat16ToFloat(FSrc);
+  const float FRef32 = convertFloat16ToFloat(FRef);
+  return std::abs(FSrc32 - FRef32) < Epsilon;
+}
+
 static bool compareFloat16ULP(const uint16_t &FSrc, const uint16_t &FRef,
                               unsigned ULPTolerance) {
   // Treat +0 and -0 as equal
@@ -113,29 +175,25 @@ static bool testAll(std::function<bool(const T &, const T &)> ComparisonFn,
   return true;
 }
 
-static bool testBufferFuzzy(offloadtest::Buffer *B1, offloadtest::Buffer *B2,
-                            unsigned ULPT, offloadtest::DenormMode DM) {
+template <typename T>
+static bool
+testBufferFloat(std::function<bool(const T &, const T &)> ComparisonFn,
+                offloadtest::Buffer *B1, offloadtest::Buffer *B2) {
   assert(B1->Format == B2->Format && "Buffer types must be the same");
   switch (B1->Format) {
   case offloadtest::DataFormat::Float64: {
     const llvm::ArrayRef<double> Arr1(
         reinterpret_cast<double *>(B1->Data.get()), B1->Size / sizeof(double));
     const llvm::ArrayRef<double> Arr2(
         reinterpret_cast<double *>(B2->Data.get()), B2->Size / sizeof(double));
-    auto Fn = [ULPT, DM](const double &FS, const double &FR) {
-      return compareDoubleULP(FS, FR, ULPT, DM);
-    };
-    return testAll<double>(Fn, Arr1, Arr2);
+    return testAll<double>(ComparisonFn, Arr1, Arr2);
   }
   case offloadtest::DataFormat::Float32: {
     const llvm::ArrayRef<float> Arr1(reinterpret_cast<float *>(B1->Data.get()),
                                      B1->Size / sizeof(float));
     const llvm::ArrayRef<float> Arr2(reinterpret_cast<float *>(B2->Data.get()),
                                      B2->Size / sizeof(float));
-    auto Fn = [ULPT, DM](const float &FS, const float &FR) {
-      return compareFloatULP(FS, FR, ULPT, DM);
-    };
-    return testAll<float>(Fn, Arr1, Arr2);
+    return testAll<float>(ComparisonFn, Arr1, Arr2);
   }
   case offloadtest::DataFormat::Float16: {
     const llvm::ArrayRef<uint16_t> Arr1(
@@ -144,10 +202,64 @@ static bool testBufferFuzzy(offloadtest::Buffer *B1, offloadtest::Buffer *B2,
     const llvm::ArrayRef<uint16_t> Arr2(
         reinterpret_cast<uint16_t *>(B2->Data.get()),
         B2->Size / sizeof(uint16_t));
+    return testAll<uint16_t>(ComparisonFn, Arr1, Arr2);
+  }
+  default:
+    llvm_unreachable("Only float types are supported by the fuzzy test.");
+  }
+  return false;
+}
+
+static bool testBufferFloatEpsilon(offloadtest::Buffer *B1,
+                                   offloadtest::Buffer *B2, double Epsilon,
+                                   offloadtest::DenormMode DM) {
+
+  switch (B1->Format) {
+  case offloadtest::DataFormat::Float64: {
+    auto Fn = [Epsilon, DM](const double &FS, const double &FR) {
+      return compareDoubleEpsilon(FS, FR, Epsilon, DM);
+    };
+    return testBufferFloat<double>(Fn, B1, B2);
+  }
+  case offloadtest::DataFormat::Float32: {
+    auto Fn = [Epsilon, DM](const float &FS, const float &FR) {
+      return compareFloatEpsilon(FS, FR, (float)Epsilon, DM);
+    };
+    return testBufferFloat<float>(Fn, B1, B2);
+  }
+  case offloadtest::DataFormat::Float16: {
+    auto Fn = [Epsilon](const uint16_t &FS, const uint16_t &FR) {
+      return compareFloat16Epsilon(FS, FR, (float)Epsilon);
+    };
+    return testBufferFloat<uint16_t>(Fn, B1, B2);
+  }
+  default:
+    llvm_unreachable("Only float types are supported by the fuzzy test.");
+  }
+  return false;
+}
+
+static bool testBufferFloatULP(offloadtest::Buffer *B1, offloadtest::Buffer *B2,
+                               unsigned ULPT, offloadtest::DenormMode DM) {
+
+  switch (B1->Format) {
+  case offloadtest::DataFormat::Float64: {
+    auto Fn = [ULPT, DM](const double &FS, const double &FR) {
+      return compareDoubleULP(FS, FR, ULPT, DM);
+    };
+    return testBufferFloat<double>(Fn, B1, B2);
+  }
+  case offloadtest::DataFormat::Float32: {
+    auto Fn = [ULPT, DM](const float &FS, const float &FR) {
+      return compareFloatULP(FS, FR, ULPT, DM);
+    };
+    return testBufferFloat<float>(Fn, B1, B2);
+  }
+  case offloadtest::DataFormat::Float16: {
     auto Fn = [ULPT](const uint16_t &FS, const uint16_t &FR) {
       return compareFloat16ULP(FS, FR, ULPT);
     };
-    return testAll<uint16_t>(Fn, Arr1, Arr2);
+    return testBufferFloat<uint16_t>(Fn, B1, B2);
   }
   default:
     llvm_unreachable("Only float types are supported by the fuzzy test.");
@@ -160,26 +272,25 @@ llvm::Error verifyResult(offloadtest::Result R) {
   case offloadtest::Rule::BufferExact: {
     if (testBufferExact(R.ActualPtr, R.ExpectedPtr))
       return llvm::Error::success();
-    llvm::SmallString<256> Str;
-    llvm::raw_svector_ostream OS(Str);
-    OS << "Test failed: " << R.Name << "\nExpected:\n";
-    llvm::yaml::Output YAMLOS(OS);
-    YAMLOS << *R.ExpectedPtr;
-    OS << "Got:\n";
-    YAMLOS << *R.ActualPtr;
-    return llvm::createStringError(Str.c_str());
-  }
-  case offloadtest::Rule::BufferFuzzy: {
-    if (testBufferFuzzy(R.ActualPtr, R.ExpectedPtr, R.ULPT, R.DM))
+    break;
+  }
+  case offloadtest::Rule::BufferFloatULP: {
+    if (testBufferFloatULP(R.ActualPtr, R.ExpectedPtr, R.ULPT, R.DM))
+      return llvm::Error::success();
+    break;
+  }
+  case offloadtest::Rule::BufferFloatEpsilon: {
+    if (testBufferFloatEpsilon(R.ActualPtr, R.ExpectedPtr, R.Epsilon, R.DM))
       return llvm::Error::success();
-    llvm::SmallString<256> Str;
-    llvm::raw_svector_ostream OS(Str);
-    OS << "Test failed: " << R.Name << "\nExpected:\n";
-    llvm::yaml::Output YAMLOS(OS);
-    YAMLOS << *R.ExpectedPtr;
-    OS << "Got:\n";
-    YAMLOS << *R.ActualPtr;
-    return llvm::createStringError(Str.c_str());
+    break;
   }
   }
+  llvm::SmallString<256> Str;
+  llvm::raw_svector_ostream OS(Str);
+  OS << "Test failed: " << R.Name << "\nExpected:\n";
+  llvm::yaml::Output YAMLOS(OS);
+  YAMLOS << *R.ExpectedPtr;
+  OS << "Got:\n";
+  YAMLOS << *R.ActualPtr;
+  return llvm::createStringError(Str.c_str());
 }

lib/Support/Pipeline.cpp

@@ -46,10 +46,11 @@ void MappingTraits<offloadtest::Pipeline>::mapping(IO &I,
       R.ExpectedPtr = P.getBuffer(R.Expected);
       if (!R.ExpectedPtr)
         I.setError(Twine("Reference buffer ") + R.Expected + " not found!");
-      if (R.Rule == Rule::BufferFuzzy) {
+      if (R.Rule == Rule::BufferFloatULP ||
+          R.Rule == Rule::BufferFloatEpsilon) {
         if (!isFloatingPointFormat(R.ActualPtr->Format) ||
             !isFloatingPointFormat(R.ExpectedPtr->Format))
-          I.setError(Twine("BufferFuzzy only accepts Float buffers"));
+          I.setError(Twine("BufferFloat only accepts Float buffers"));
         if (R.ActualPtr->Format != R.ExpectedPtr->Format)
           I.setError(Twine("Buffers must have the same type"));
       }
@@ -230,11 +231,16 @@ void MappingTraits<offloadtest::Result>::mapping(IO &I,
   I.mapRequired("Expected", R.Expected);
 
   switch (R.Rule) {
-  case Rule::BufferFuzzy: {
+  case Rule::BufferFloatULP: {
     I.mapRequired("ULPT", R.ULPT);
     I.mapOptional("DenormMode", R.DM);
     break;
   }
+  case Rule::BufferFloatEpsilon: {
+    I.mapRequired("Epsilon", R.Epsilon);
+    I.mapOptional("DenormMode", R.DM);
+    break;
+  }
   default:
     break;
   }

test/Tools/Offloader/BufferFuzzy-16bit.test renamed to test/Tools/Offloader/BufferFloat-16bit.test

@@ -65,30 +65,56 @@ Buffers:
     Data: [ 0, 0 ] # compare negative and positive zero
 Results:
   - Result: Test1 # Test two values are exactly the same
-    Rule: BufferFuzzy
+    Rule: BufferFloatULP
     ULPT: 0 # ulp shouldn't matter for this test
     Actual: Out1
     Expected: Expected1
   - Result: Test2 # Test both are NaN
-    Rule: BufferFuzzy
+    Rule: BufferFloatULP
     ULPT: 0 # ulp shouldn't matter for this test
     Actual: Out2
     Expected: Expected2
   - Result: Test3 # Actual and Expected are not the same but they are within the ULPT
-    Rule: BufferFuzzy
+    Rule: BufferFloatULP
     ULPT: 1
     Actual: Out3
     Expected: Expected3
   - Result: Test4 # Actual and Expected are not the same but they are within the ULPT
-    Rule: BufferFuzzy
+    Rule: BufferFloatULP
     ULPT: 2
     Actual: Out4
     Expected: Expected4
   - Result: Test5 # +0 and -0 should be equal
-    Rule: BufferFuzzy
+    Rule: BufferFloatULP
     ULPT: 0
     Actual: Out5
     Expected: Expected5
+  # test BufferFloatEpsilon
+  - Result: Test6 # Test two values are exactly the same
+    Rule: BufferFloatEpsilon
+    Epsilon: 0
+    Actual: Out1
+    Expected: Expected1
+  - Result: Test7 # Test both are NaN
+    Rule: BufferFloatEpsilon
+    Epsilon: 0 # epsilon shouldn't matter for this test
+    Actual: Out2
+    Expected: Expected2
+  - Result: Test8 # Actual and Expected are not the same but they are within the epsilon
+    Rule: BufferFloatEpsilon
+    Epsilon: 0.004
+    Actual: Out3
+    Expected: Expected3
+  - Result: Test9 # Actual and Expected are not the same but they are within the epsilon
+    Rule: BufferFloatEpsilon
+    Epsilon: 0.008
+    Actual: Out4
+    Expected: Expected4
+  - Result: Test10 # +0 and -0 should be equal
+    Rule: BufferFloatEpsilon
+    Epsilon: 0
+    Actual: Out5
+    Expected: Expected5
 DescriptorSets:
   - Resources:
     - Name: Out1