[Offload][Conformance] Add exhaustive tests for half-precision math functions (#155112)

This patch adds a set of exhaustive tests for half-precision math.

The functions included in this set were selected based on the following
criteria:
- An implementation exists in `libc/src/math/generic` (i.e., it is not
just a wrapper around a compiler built-in).
- The corresponding LLVM CPU libm implementation is correctly rounded.
- The function is listed in Table 69 of the OpenCL C Specification
v3.0.19.

This patch also fixes the testing range of the following functions:
`acos`, `acosf`, `asin`, `asinf`, and `log1p`.

Author: leandrolcampos

offload/unittests/Conformance/device_code/DeviceAPIs.hpp

@@ -103,49 +103,68 @@ extern "C" {
 
 double __ocml_acos_f64(double);
 float __ocml_acos_f32(float);
+float16 __ocml_acos_f16(float16);
 float __ocml_acosh_f32(float);
+float16 __ocml_acosh_f16(float16);
 double __ocml_asin_f64(double);
 float __ocml_asin_f32(float);
+float16 __ocml_asin_f16(float16);
 float __ocml_asinh_f32(float);
+float16 __ocml_asinh_f16(float16);
 float __ocml_atan_f32(float);
+float16 __ocml_atan_f16(float16);
 float __ocml_atan2_f32(float, float);
 float __ocml_atanh_f32(float);
+float16 __ocml_atanh_f16(float16);
 double __ocml_cbrt_f64(double);
 float __ocml_cbrt_f32(float);
 double __ocml_cos_f64(double);
 float __ocml_cos_f32(float);
+float16 __ocml_cos_f16(float16);
 float __ocml_cosh_f32(float);
+float16 __ocml_cosh_f16(float16);
 float __ocml_cospi_f32(float);
 float __ocml_erf_f32(float);
 double __ocml_exp_f64(double);
 float __ocml_exp_f32(float);
+float16 __ocml_exp_f16(float16);
 double __ocml_exp10_f64(double);
 float __ocml_exp10_f32(float);
+float16 __ocml_exp10_f16(float16);
 double __ocml_exp2_f64(double);
 float __ocml_exp2_f32(float);
+float16 __ocml_exp2_f16(float16);
 double __ocml_expm1_f64(double);
 float __ocml_expm1_f32(float);
+float16 __ocml_expm1_f16(float16);
 double __ocml_hypot_f64(double, double);
 float __ocml_hypot_f32(float, float);
 double __ocml_log_f64(double);
 float __ocml_log_f32(float);
+float16 __ocml_log_f16(float16);
 double __ocml_log10_f64(double);
 float __ocml_log10_f32(float);
+float16 __ocml_log10_f16(float16);
 double __ocml_log1p_f64(double);
 float __ocml_log1p_f32(float);
 double __ocml_log2_f64(double);
 float __ocml_log2_f32(float);
+float16 __ocml_log2_f16(float16);
 float __ocml_pow_f32(float, float);
 float __ocml_round_f32(float);
 double __ocml_sin_f64(double);
 float __ocml_sin_f32(float);
+float16 __ocml_sin_f16(float16);
 double __ocml_sincos_f64(double, double *);
 float __ocml_sincos_f32(float, float *);
 float __ocml_sinh_f32(float);
+float16 __ocml_sinh_f16(float16);
 float __ocml_sinpi_f32(float);
 double __ocml_tan_f64(double);
 float __ocml_tan_f32(float);
+float16 __ocml_tan_f16(float16);
 float __ocml_tanh_f32(float);
+float16 __ocml_tanh_f16(float16);
 } // extern "C"
 
 #endif // HIP_MATH_FOUND

offload/unittests/Conformance/device_code/HIPMath.cpp

@@ -70,11 +70,21 @@ __gpu_kernel void acosfKernel(const float *X, float *Out,
   runKernelBody<__ocml_acos_f32>(NumElements, Out, X);
 }
 
+__gpu_kernel void acosf16Kernel(const float16 *X, float16 *Out,
+                                size_t NumElements) noexcept {
+  runKernelBody<__ocml_acos_f16>(NumElements, Out, X);
+}
+
 __gpu_kernel void acoshfKernel(const float *X, float *Out,
                                size_t NumElements) noexcept {
   runKernelBody<__ocml_acosh_f32>(NumElements, Out, X);
 }
 
+__gpu_kernel void acoshf16Kernel(const float16 *X, float16 *Out,
+                                 size_t NumElements) noexcept {
+  runKernelBody<__ocml_acosh_f16>(NumElements, Out, X);
+}
+
 __gpu_kernel void asinKernel(const double *X, double *Out,
                              size_t NumElements) noexcept {
   runKernelBody<__ocml_asin_f64>(NumElements, Out, X);
@@ -85,16 +95,31 @@ __gpu_kernel void asinfKernel(const float *X, float *Out,
   runKernelBody<__ocml_asin_f32>(NumElements, Out, X);
 }
 
+__gpu_kernel void asinf16Kernel(const float16 *X, float16 *Out,
+                                size_t NumElements) noexcept {
+  runKernelBody<__ocml_asin_f16>(NumElements, Out, X);
+}
+
 __gpu_kernel void asinhfKernel(const float *X, float *Out,
                                size_t NumElements) noexcept {
   runKernelBody<__ocml_asinh_f32>(NumElements, Out, X);
 }
 
+__gpu_kernel void asinhf16Kernel(const float16 *X, float16 *Out,
+                                 size_t NumElements) noexcept {
+  runKernelBody<__ocml_asinh_f16>(NumElements, Out, X);
+}
+
 __gpu_kernel void atanfKernel(const float *X, float *Out,
                               size_t NumElements) noexcept {
   runKernelBody<__ocml_atan_f32>(NumElements, Out, X);
 }
 
+__gpu_kernel void atanf16Kernel(const float16 *X, float16 *Out,
+                                size_t NumElements) noexcept {
+  runKernelBody<__ocml_atan_f16>(NumElements, Out, X);
+}
+
 __gpu_kernel void atan2fKernel(const float *X, const float *Y, float *Out,
                                size_t NumElements) noexcept {
   runKernelBody<__ocml_atan2_f32>(NumElements, Out, X, Y);
@@ -105,6 +130,11 @@ __gpu_kernel void atanhfKernel(const float *X, float *Out,
   runKernelBody<__ocml_atanh_f32>(NumElements, Out, X);
 }
 
+__gpu_kernel void atanhf16Kernel(const float16 *X, float16 *Out,
+                                 size_t NumElements) noexcept {
+  runKernelBody<__ocml_atanh_f16>(NumElements, Out, X);
+}
+
 __gpu_kernel void cbrtKernel(const double *X, double *Out,
                              size_t NumElements) noexcept {
   runKernelBody<__ocml_cbrt_f64>(NumElements, Out, X);
@@ -125,11 +155,21 @@ __gpu_kernel void cosfKernel(const float *X, float *Out,
   runKernelBody<__ocml_cos_f32>(NumElements, Out, X);
 }
 
+__gpu_kernel void cosf16Kernel(const float16 *X, float16 *Out,
+                               size_t NumElements) noexcept {
+  runKernelBody<__ocml_cos_f16>(NumElements, Out, X);
+}
+
 __gpu_kernel void coshfKernel(const float *X, float *Out,
                               size_t NumElements) noexcept {
   runKernelBody<__ocml_cosh_f32>(NumElements, Out, X);
 }
 
+__gpu_kernel void coshf16Kernel(const float16 *X, float16 *Out,
+                                size_t NumElements) noexcept {
+  runKernelBody<__ocml_cosh_f16>(NumElements, Out, X);
+}
+
 __gpu_kernel void cospifKernel(const float *X, float *Out,
                                size_t NumElements) noexcept {
   runKernelBody<__ocml_cospi_f32>(NumElements, Out, X);
@@ -150,6 +190,11 @@ __gpu_kernel void expfKernel(const float *X, float *Out,
   runKernelBody<__ocml_exp_f32>(NumElements, Out, X);
 }
 
+__gpu_kernel void expf16Kernel(const float16 *X, float16 *Out,
+                               size_t NumElements) noexcept {
+  runKernelBody<__ocml_exp_f16>(NumElements, Out, X);
+}
+
 __gpu_kernel void exp10Kernel(const double *X, double *Out,
                               size_t NumElements) noexcept {
   runKernelBody<__ocml_exp10_f64>(NumElements, Out, X);
@@ -160,6 +205,11 @@ __gpu_kernel void exp10fKernel(const float *X, float *Out,
   runKernelBody<__ocml_exp10_f32>(NumElements, Out, X);
 }
 
+__gpu_kernel void exp10f16Kernel(const float16 *X, float16 *Out,
+                                 size_t NumElements) noexcept {
+  runKernelBody<__ocml_exp10_f16>(NumElements, Out, X);
+}
+
 __gpu_kernel void exp2Kernel(const double *X, double *Out,
                              size_t NumElements) noexcept {
   runKernelBody<__ocml_exp2_f64>(NumElements, Out, X);
@@ -170,6 +220,11 @@ __gpu_kernel void exp2fKernel(const float *X, float *Out,
   runKernelBody<__ocml_exp2_f32>(NumElements, Out, X);
 }
 
+__gpu_kernel void exp2f16Kernel(const float16 *X, float16 *Out,
+                                size_t NumElements) noexcept {
+  runKernelBody<__ocml_exp2_f16>(NumElements, Out, X);
+}
+
 __gpu_kernel void expm1Kernel(const double *X, double *Out,
                               size_t NumElements) noexcept {
   runKernelBody<__ocml_expm1_f64>(NumElements, Out, X);
@@ -180,6 +235,11 @@ __gpu_kernel void expm1fKernel(const float *X, float *Out,
   runKernelBody<__ocml_expm1_f32>(NumElements, Out, X);
 }
 
+__gpu_kernel void expm1f16Kernel(const float16 *X, float16 *Out,
+                                 size_t NumElements) noexcept {
+  runKernelBody<__ocml_expm1_f16>(NumElements, Out, X);
+}
+
 __gpu_kernel void hypotKernel(const double *X, const double *Y, double *Out,
                               size_t NumElements) noexcept {
   runKernelBody<__ocml_hypot_f64>(NumElements, Out, X, Y);
@@ -200,6 +260,11 @@ __gpu_kernel void logfKernel(const float *X, float *Out,
   runKernelBody<__ocml_log_f32>(NumElements, Out, X);
 }
 
+__gpu_kernel void logf16Kernel(const float16 *X, float16 *Out,
+                               size_t NumElements) noexcept {
+  runKernelBody<__ocml_log_f16>(NumElements, Out, X);
+}
+
 __gpu_kernel void log10Kernel(const double *X, double *Out,
                               size_t NumElements) noexcept {
   runKernelBody<__ocml_log10_f64>(NumElements, Out, X);
@@ -210,6 +275,11 @@ __gpu_kernel void log10fKernel(const float *X, float *Out,
   runKernelBody<__ocml_log10_f32>(NumElements, Out, X);
 }
 
+__gpu_kernel void log10f16Kernel(const float16 *X, float16 *Out,
+                                 size_t NumElements) noexcept {
+  runKernelBody<__ocml_log10_f16>(NumElements, Out, X);
+}
+
 __gpu_kernel void log1pKernel(const double *X, double *Out,
                               size_t NumElements) noexcept {
   runKernelBody<__ocml_log1p_f64>(NumElements, Out, X);
@@ -230,6 +300,11 @@ __gpu_kernel void log2fKernel(const float *X, float *Out,
   runKernelBody<__ocml_log2_f32>(NumElements, Out, X);
 }
 
+__gpu_kernel void log2f16Kernel(const float16 *X, float16 *Out,
+                                size_t NumElements) noexcept {
+  runKernelBody<__ocml_log2_f16>(NumElements, Out, X);
+}
+
 __gpu_kernel void powfKernel(const float *X, float *Y, float *Out,
                              size_t NumElements) noexcept {
   runKernelBody<__ocml_pow_f32>(NumElements, Out, X, Y);
@@ -251,6 +326,11 @@ __gpu_kernel void sinfKernel(const float *X, float *Out,
   runKernelBody<__ocml_sin_f32>(NumElements, Out, X);
 }
 
+__gpu_kernel void sinf16Kernel(const float16 *X, float16 *Out,
+                               size_t NumElements) noexcept {
+  runKernelBody<__ocml_sin_f16>(NumElements, Out, X);
+}
+
 __gpu_kernel void sincosSinKernel(const double *X, double *Out,
                                   size_t NumElements) noexcept {
   runKernelBody<sincosSin>(NumElements, Out, X);
@@ -276,6 +356,11 @@ __gpu_kernel void sinhfKernel(const float *X, float *Out,
   runKernelBody<__ocml_sinh_f32>(NumElements, Out, X);
 }
 
+__gpu_kernel void sinhf16Kernel(const float16 *X, float16 *Out,
+                                size_t NumElements) noexcept {
+  runKernelBody<__ocml_sinh_f16>(NumElements, Out, X);
+}
+
 __gpu_kernel void sinpifKernel(const float *X, float *Out,
                                size_t NumElements) noexcept {
   runKernelBody<__ocml_sinpi_f32>(NumElements, Out, X);
@@ -291,10 +376,20 @@ __gpu_kernel void tanfKernel(const float *X, float *Out,
   runKernelBody<__ocml_tan_f32>(NumElements, Out, X);
 }
 
+__gpu_kernel void tanf16Kernel(const float16 *X, float16 *Out,
+                               size_t NumElements) noexcept {
+  runKernelBody<__ocml_tan_f16>(NumElements, Out, X);
+}
+
 __gpu_kernel void tanhfKernel(const float *X, float *Out,
                               size_t NumElements) noexcept {
   runKernelBody<__ocml_tanh_f32>(NumElements, Out, X);
 }
+
+__gpu_kernel void tanhf16Kernel(const float16 *X, float16 *Out,
+                                size_t NumElements) noexcept {
+  runKernelBody<__ocml_tanh_f16>(NumElements, Out, X);
+}
 } // extern "C"
 
 #endif // HIP_MATH_FOUND