Feedback, and remove expm1 test.

Author: mcourteaux

src/FastMathFunctions.cpp

@@ -61,6 +61,10 @@ Expr eval_poly_horner(const std::vector<double> &coefs, const Expr &x) {
      * R = a0 + x * a1 + x^2 * a2 + x^3 * a3
      *   = a0 + x * (a1 + x * a2 + x^2 * a3)
      *   = a0 + x * (a1 + x * (a2 + x * a3))
+     *
+     * This is known as Horner's method.
+     * Fun fact: even if we don't program it like this, the Halide expression
+     * rewriter will turn it into this Horner format.
      */
     Type type = x.type();
     if (coefs.empty()) {
@@ -680,6 +684,10 @@ bool intrinsic_satisfies_precision(const IntrinsicsInfo &ii, const Approximation
             }
         } else {
             // We don't know?
+            // TODO(mcourteaux): We haven't measured the intrinsics on this particular
+            // device API yet. We could report a warning, but that's perhaps too invasive.
+            // Let's report it in debug(1) instead to have people notice this.
+            debug(1) << "Warning: intrinsic is defined but not yet measured in terms of ULP precision.\n";
         }
     }
     if (prec.constraint_max_absolute_error != 0) {
@@ -689,6 +697,8 @@ bool intrinsic_satisfies_precision(const IntrinsicsInfo &ii, const Approximation
             }
         } else {
             // We don't know?
+            // TODO(mcourteaux): Read above.
+            debug(1) << "Warning: intrinsic is defined but not yet measured in terms of MAE precision.\n";
         }
     }
     return true;
@@ -711,6 +721,11 @@ bool native_func_satisfies_precision(const IntrinsicsInfo &ii, const Approximati
             }
         } else {
             // We don't know?
+            // TODO(mcourteaux): We could report a warning that we assume the
+            // precision is unknown, but I'll postpone this for when we have
+            // strict_float, and only warn in case of string_float requirements.
+            // For now let's report it in debug(1) such that we won't forget about this.
+            debug(1) << "Warning: native func is defined but not yet measured in terms of MAE precision.\n";
         }
     }
     if (prec.constraint_max_absolute_error != 0) {
@@ -720,6 +735,8 @@ bool native_func_satisfies_precision(const IntrinsicsInfo &ii, const Approximati
             }
         } else {
             // We don't know?
+            // TODO(mcourteaux): Read above.
+            debug(1) << "Warning: native func is defined but not yet measured in terms of ULP precision.\n";
         }
     }
     return true;

src/IROperator.cpp

@@ -2194,17 +2194,6 @@ Expr hypot(const Expr &x, const Expr &y) {
     return sqrt(x * x + y * y);
 }
 
-Expr expm1(Expr x) {
-    user_assert(x.defined()) << "exp of undefined Expr\n";
-    if (x.type() == Float(64)) {
-        return Call::make(Float(64), "expm1_f64", {std::move(x)}, Call::PureExtern);
-    } else if (x.type() == Float(16)) {
-        return Call::make(Float(16), "expm1_f16", {std::move(x)}, Call::PureExtern);
-    } else {
-        return Call::make(Float(32), "expm1_f32", {cast<float>(std::move(x))}, Call::PureExtern);
-    }
-}
-
 Expr exp(Expr x) {
     user_assert(x.defined()) << "exp of undefined Expr\n";
     if (x.type() == Float(64)) {

src/IROperator.h

@@ -956,15 +956,6 @@ Expr hypot(const Expr &x, const Expr &y);
  * mantissa. Vectorizes cleanly. */
 Expr exp(Expr x);
 
-/** Return the exponential of a floating-point expression. If the
- * argument is not floating-point, it is cast to Float(32). For
- * Float(64) arguments, this calls the system exp function, and does
- * not vectorize well. For Float(32) arguments, this function is
- * vectorizable, does the right thing for extremely small or extremely
- * large inputs, and is accurate up to the last bit of the
- * mantissa. Vectorizes cleanly. */
-Expr expm1(Expr x);
-
 /** Return the logarithm of a floating-point expression. If the
  * argument is not floating-point, it is cast to Float(32). For
  * Float(64) arguments, this calls the system log function, and does
@@ -992,7 +983,7 @@ Expr erf(const Expr &x);
  * hardware instructions. If no hardware instructions are available, approximations
  * are implemented in Halide using polynomials or potentially Padé approximants.
  * Both the hardware instructions and the in-house approximations have a certain behavior
- * and precision. This struct allows you to specifiy which behavior and precision you
+ * and precision. This struct allows you to specify which behavior and precision you
  * are interested in. Halide will select an appropriate implemenation that satisfies
  * these requirements.
  *

test/performance/fast_function_approximations.cpp

@@ -252,39 +252,23 @@ int main(int argc, char **argv) {
             }
             if (should_be_faster) num_tests++;
 
-            int goodness = 0;
-
             if (pipeline_time_ref < approx_pipeline_time * 0.90) {
                 printf("   %6.1f%% slower", -100.0f * (1.0f - approx_pipeline_time / pipeline_time_ref));
                 if (!should_be_faster) {
-                    printf("  (expected)");
-                    goodness = 1;
+                    printf("  (expected) 😐");
                 } else {
-                    printf("!!");
-                    goodness = 0;
+                    printf("!! ❌");
                 }
             } else if (pipeline_time_ref < approx_pipeline_time * 1.10) {
                 printf("   equally fast (%+5.1f%% faster)",
                        100.0f * (1.0f - approx_pipeline_time / pipeline_time_ref));
                 if (should_be_faster) num_passed++;
-                goodness = 1;
+                printf(" 😐");
             } else {
                 printf("   %4.1f%% faster",
                        100.0f * (1.0f - approx_pipeline_time / pipeline_time_ref));
                 if (should_be_faster) num_passed++;
-                goodness = 2;
-            }
-
-            switch (goodness) {
-            case 0:
-                printf(" ❌");
-                break;
-            case 1:
-                printf(" 😐");
-                break;
-            case 2:
                 printf(" ✅");
-                break;
             }
             printf("\n");
         }