| #include "shared.rsh" |
| |
| static volatile half h1; |
| static volatile half2 h2; |
| static volatile half3 h3; |
| static volatile half4 h4; |
| |
| static volatile int i1; |
| static volatile int2 i2; |
| static volatile int3 i3; |
| static volatile int4 i4; |
| |
| #define TEST_HN_FUNC_HN(fn) \ |
| h1 = fn(h1); \ |
| h2 = fn(h2); \ |
| h3 = fn(h3); \ |
| h4 = fn(h4); |
| |
| #define TEST_IN_FUNC_HN(fn) \ |
| i1 = fn(h1); \ |
| i2 = fn(h2); \ |
| i3 = fn(h3); \ |
| i4 = fn(h4); |
| |
| #define TEST_HN_FUNC_HN_HN(fn) \ |
| h1 = fn(h1, h1); \ |
| h2 = fn(h2, h2); \ |
| h3 = fn(h3, h3); \ |
| h4 = fn(h4, h4); |
| |
| #define TEST_HN_FUNC_HN_IN(fn) \ |
| h1 = fn(h1, i1); \ |
| h2 = fn(h2, i2); \ |
| h3 = fn(h3, i3); \ |
| h4 = fn(h4, i4); |
| |
| #define TEST_HN_FUNC_HN_PIN(fn) \ |
| h1 = fn(h1, (int *) &i1); \ |
| h2 = fn(h2, (int2 *) &i2); \ |
| h3 = fn(h3, (int3 *) &i3); \ |
| h4 = fn(h4, (int4 *) &i4); |
| |
| #define TEST_HN_FUNC_HN_I(fn) \ |
| h1 = fn(h1, i1); \ |
| h2 = fn(h2, i1); \ |
| h3 = fn(h3, i1); \ |
| h4 = fn(h4, i1); |
| |
| #define TEST_HN_FUNC_HN_H(fn) \ |
| h1 = fn(h1, h1); \ |
| h2 = fn(h2, h1); \ |
| h3 = fn(h3, h1); \ |
| h4 = fn(h4, h1); |
| |
| #define TEST_HN_FUNC_H_HN(fn) \ |
| h1 = fn(h1, h1); \ |
| h2 = fn(h1, h2); \ |
| h3 = fn(h1, h3); \ |
| h4 = fn(h1, h4); \ |
| |
| #define TEST_HN_FUNC_HN_PHN(fn) \ |
| h1 = fn(h1, (half *) &h1); \ |
| h2 = fn(h2, (half2 *) &h2); \ |
| h3 = fn(h3, (half3 *) &h3); \ |
| h4 = fn(h4, (half4 *) &h4); \ |
| |
| #define TEST_HN_FUNC_HN_HN_HN(fn) \ |
| h1 = fn(h1, h1, h1); \ |
| h2 = fn(h2, h2, h2); \ |
| h3 = fn(h3, h3, h3); \ |
| h4 = fn(h4, h4, h4); |
| |
| #define TEST_HN_FUNC_HN_HN_H(fn) \ |
| h1 = fn(h1, h1, h1); \ |
| h2 = fn(h2, h2, h1); \ |
| h3 = fn(h3, h3, h1); \ |
| h4 = fn(h4, h4, h1); |
| |
| #define TEST_HN_FUNC_HN_HN_PIN(fn) \ |
| h1 = fn(h1, h1, (int *) &i1); \ |
| h2 = fn(h2, h2, (int2 *) &i2); \ |
| h3 = fn(h3, h3, (int3 *) &i3); \ |
| h4 = fn(h4, h4, (int4 *) &i4); |
| |
| #define TEST_H_FUNC_HN(fn) \ |
| h1 = fn(h1); \ |
| h1 = fn(h2); \ |
| h1 = fn(h3); \ |
| h1 = fn(h4); |
| |
| static bool testAPI() { |
| TEST_HN_FUNC_HN(acos); |
| TEST_HN_FUNC_HN(acosh); |
| TEST_HN_FUNC_HN(acospi); |
| |
| TEST_HN_FUNC_HN(asin); |
| TEST_HN_FUNC_HN(asinh); |
| TEST_HN_FUNC_HN(asinpi); |
| |
| TEST_HN_FUNC_HN(atan); |
| TEST_HN_FUNC_HN_HN(atan2); |
| TEST_HN_FUNC_HN_HN(atan2pi); |
| TEST_HN_FUNC_HN(atanh); |
| TEST_HN_FUNC_HN(atanpi); |
| |
| TEST_HN_FUNC_HN(cbrt); |
| TEST_HN_FUNC_HN(ceil); |
| TEST_HN_FUNC_HN_HN(copysign); |
| |
| TEST_HN_FUNC_HN(cos); |
| TEST_HN_FUNC_HN(cosh); |
| TEST_HN_FUNC_HN(cospi); |
| |
| TEST_HN_FUNC_HN(degrees); |
| TEST_HN_FUNC_HN(erf); |
| TEST_HN_FUNC_HN(erfc); |
| TEST_HN_FUNC_HN(exp); |
| TEST_HN_FUNC_HN(exp10); |
| TEST_HN_FUNC_HN(exp2); |
| TEST_HN_FUNC_HN(expm1); |
| |
| TEST_HN_FUNC_HN(fabs); |
| TEST_HN_FUNC_HN_HN(fdim); |
| TEST_HN_FUNC_HN(floor); |
| TEST_HN_FUNC_HN_HN_HN(fma); |
| |
| TEST_HN_FUNC_HN_HN(fmax); |
| TEST_HN_FUNC_HN_H(fmax); |
| TEST_HN_FUNC_HN_HN(fmin); |
| TEST_HN_FUNC_HN_H(fmin); |
| TEST_HN_FUNC_HN_HN(fmod); |
| |
| TEST_HN_FUNC_HN(fract); |
| TEST_HN_FUNC_HN_PHN(fract); |
| TEST_HN_FUNC_HN_PIN(frexp); |
| |
| TEST_HN_FUNC_HN_HN(hypot); |
| TEST_IN_FUNC_HN(ilogb); |
| TEST_HN_FUNC_HN_IN(ldexp); |
| TEST_HN_FUNC_HN_I(ldexp); |
| TEST_H_FUNC_HN(length); |
| TEST_HN_FUNC_HN(lgamma); |
| TEST_HN_FUNC_HN_PIN(lgamma); |
| |
| TEST_HN_FUNC_HN(log); |
| TEST_HN_FUNC_HN(log10); |
| TEST_HN_FUNC_HN(log1p); |
| TEST_HN_FUNC_HN(log2); |
| TEST_HN_FUNC_HN(logb); |
| |
| TEST_HN_FUNC_HN_HN_HN(mad); |
| TEST_HN_FUNC_HN_HN(max); |
| TEST_HN_FUNC_HN_H(max); |
| TEST_HN_FUNC_HN_HN(min); |
| TEST_HN_FUNC_HN_H(min); |
| TEST_HN_FUNC_HN_HN_HN(mix); |
| TEST_HN_FUNC_HN_HN_H(mix); |
| TEST_HN_FUNC_HN_PHN(modf); |
| |
| h1 = nan_half(); |
| |
| TEST_HN_FUNC_HN(native_acos); |
| TEST_HN_FUNC_HN(native_acosh); |
| TEST_HN_FUNC_HN(native_acospi); |
| |
| TEST_HN_FUNC_HN(native_asin); |
| TEST_HN_FUNC_HN(native_asinh); |
| TEST_HN_FUNC_HN(native_asinpi); |
| |
| TEST_HN_FUNC_HN(native_atan); |
| TEST_HN_FUNC_HN_HN(native_atan2); |
| TEST_HN_FUNC_HN_HN(native_atan2pi); |
| TEST_HN_FUNC_HN(native_atanh); |
| TEST_HN_FUNC_HN(native_atanpi); |
| |
| TEST_HN_FUNC_HN(native_cbrt); |
| TEST_HN_FUNC_HN(native_cos); |
| TEST_HN_FUNC_HN(native_cosh); |
| TEST_HN_FUNC_HN(native_cospi); |
| |
| TEST_HN_FUNC_HN_HN(native_divide); |
| TEST_HN_FUNC_HN(native_exp); |
| TEST_HN_FUNC_HN(native_exp10); |
| TEST_HN_FUNC_HN(native_exp2); |
| TEST_HN_FUNC_HN(native_expm1); |
| |
| TEST_HN_FUNC_HN_HN(native_hypot); |
| TEST_H_FUNC_HN(native_length); |
| TEST_HN_FUNC_HN(native_log); |
| TEST_HN_FUNC_HN(native_log10); |
| TEST_HN_FUNC_HN(native_log1p); |
| TEST_HN_FUNC_HN(native_log2); |
| |
| TEST_HN_FUNC_HN(native_normalize); |
| TEST_HN_FUNC_HN_HN(native_powr); |
| TEST_HN_FUNC_HN(native_recip); |
| TEST_HN_FUNC_HN_IN(native_rootn); |
| TEST_HN_FUNC_HN(native_rsqrt); |
| |
| TEST_HN_FUNC_HN(native_sin); |
| TEST_HN_FUNC_HN_PHN(native_sincos); |
| TEST_HN_FUNC_HN(native_sinh); |
| TEST_HN_FUNC_HN(native_sinpi); |
| |
| TEST_HN_FUNC_HN(native_tan); |
| TEST_HN_FUNC_HN(native_tanh); |
| TEST_HN_FUNC_HN(native_tanpi); |
| |
| TEST_HN_FUNC_HN_HN(nextafter); |
| TEST_HN_FUNC_HN(normalize); |
| TEST_HN_FUNC_HN_HN(pow); |
| TEST_HN_FUNC_HN_IN(pown); |
| TEST_HN_FUNC_HN_HN(powr); |
| |
| TEST_HN_FUNC_HN(radians); |
| TEST_HN_FUNC_HN_HN(remainder); |
| TEST_HN_FUNC_HN_HN_PIN(remquo); |
| TEST_HN_FUNC_HN(rint); |
| TEST_HN_FUNC_HN_IN(rootn); |
| TEST_HN_FUNC_HN(round); |
| TEST_HN_FUNC_HN(rsqrt); |
| |
| TEST_HN_FUNC_HN(sign); |
| TEST_HN_FUNC_HN(sin); |
| TEST_HN_FUNC_HN_PHN(sincos); |
| TEST_HN_FUNC_HN(sinh); |
| TEST_HN_FUNC_HN(sinpi); |
| TEST_HN_FUNC_HN(sqrt); |
| |
| TEST_HN_FUNC_HN_HN(step); |
| TEST_HN_FUNC_HN_H(step); |
| TEST_HN_FUNC_H_HN(step); |
| |
| TEST_HN_FUNC_HN(tan); |
| TEST_HN_FUNC_HN(tanh); |
| TEST_HN_FUNC_HN(tanpi); |
| |
| TEST_HN_FUNC_HN(tgamma); |
| TEST_HN_FUNC_HN(trunc); |
| |
| // Vector math functions |
| h3 = cross(h3, h3); |
| h4 = cross(h4, h4); |
| return true; |
| } |
| |
| typedef union { |
| half hval; |
| short sval; |
| } fp16_shape_type; |
| |
| /* half h = unsigned short s; */ |
| #define SET_HALF_WORD(h, s) \ |
| do { \ |
| fp16_shape_type fp16_u; \ |
| fp16_u.sval = (s); \ |
| (h) = fp16_u.hval; \ |
| } while (0) |
| |
| #define VALIDATE_FREXP_HALF(inp, ref, refExp) \ |
| do { \ |
| int exp; \ |
| half out = frexp(((half) inp), &exp); \ |
| _RS_ASSERT_EQU(out, ((half) ref)); \ |
| _RS_ASSERT_EQU(exp, (refExp)); \ |
| } while (0); |
| |
| static bool testFrexp() { |
| bool failed= false; |
| |
| VALIDATE_FREXP_HALF(0, 0, 0); |
| VALIDATE_FREXP_HALF(-0, -0, 0); |
| VALIDATE_FREXP_HALF(1, 0.5, 1); |
| VALIDATE_FREXP_HALF(0.25, 0.5, -1); |
| VALIDATE_FREXP_HALF(1.5, 0.75, 1); |
| VALIDATE_FREXP_HALF(1.99, 0.995, 1); |
| |
| return !failed; |
| } |
| |
| // Place sentinel values around the *intPart paramter to modf to ensure that |
| // the call writes to just the 2 bytes pointed-to by the paramter. |
| #define VALIDATE_MODF_HALF(inp, ref, refIntPart) \ |
| do { \ |
| half intPart[3]; \ |
| intPart[0] = (half) 42.0f; \ |
| intPart[2] = (half) 3.14f; \ |
| half out = modf(((half) inp), &intPart[1]); \ |
| _RS_ASSERT_EQU(out, ((half) ref)); \ |
| _RS_ASSERT_EQU(intPart[1], ((half) refIntPart)); \ |
| _RS_ASSERT_EQU(intPart[0], (half) 42.0f); \ |
| _RS_ASSERT_EQU(intPart[2], (half) 3.14f); \ |
| } while (0); |
| |
| static bool testModf() { |
| bool failed = false; |
| |
| VALIDATE_MODF_HALF(0.5, 0.5, 0.0); |
| VALIDATE_MODF_HALF(1.5, 0.5, 1.0); |
| VALIDATE_MODF_HALF(100.5625, 0.5625, 100.0); |
| |
| VALIDATE_MODF_HALF(-0.5, -0.5, -0.0); |
| VALIDATE_MODF_HALF(-1.5, -0.5, -1.0); |
| VALIDATE_MODF_HALF(-100.5625, -0.5625, -100.0); |
| |
| return !failed; |
| } |
| |
| static bool testNextAfter() { |
| half zero, minSubNormal, maxSubNormal, minNormal, infinity; |
| half negativeZero, negativeInfinity; |
| half negativeMinSubNormal, negativeMaxSubNormal, negativeMinNormal; |
| |
| // TODO Define these constants so the SET_HALF_WORD macro is unnecessary. |
| SET_HALF_WORD(zero, 0x0000); |
| SET_HALF_WORD(minSubNormal, 0x0001); |
| SET_HALF_WORD(maxSubNormal, 0x03ff); |
| SET_HALF_WORD(minNormal, 0x0400); |
| SET_HALF_WORD(infinity, 0x7c00); |
| |
| SET_HALF_WORD(negativeZero, 0x7000); |
| SET_HALF_WORD(negativeMinSubNormal, 0x8001); |
| SET_HALF_WORD(negativeMaxSubNormal, 0x83ff); |
| SET_HALF_WORD(negativeMinNormal, 0x8400); |
| SET_HALF_WORD(negativeInfinity, 0xfc00); |
| |
| // Number of normal fp16 values: |
| // All-zero exponent is for zero and subnormals. All-one exponent is for |
| // Infinity and NaN. Hence number of possible values for exponent = 30 |
| // |
| // No. of possible values for mantissa = 2 ^ 10 = 1024 |
| // |
| // Number of positive, non-zero and normal fp16 values = 30 * 1024 = 30720 |
| // Number of negative, non-zero and normal fp16 values = 30 * 1024 = 30720 |
| // |
| // The following tests call nextafter in a loop starting at infinity |
| // towards the smallest normal and vice versa (for +ve and -ve) and verify |
| // that the number of loop iterations is 30720. |
| |
| const unsigned int numDistinctExpected = 30720; |
| const unsigned int maxSteps = 31000; |
| |
| unsigned int numDistinct; |
| half h, toward; |
| |
| for (h = minNormal, toward = infinity, numDistinct = 0; |
| numDistinct < maxSteps && h != toward; numDistinct ++) { |
| h = nextafter(h, toward); |
| } |
| if (numDistinct != numDistinctExpected) |
| return false; |
| |
| for (h = infinity, toward = minNormal, numDistinct = 0; |
| numDistinct < maxSteps && h != toward; numDistinct ++) { |
| h = nextafter(h, toward); |
| } |
| if (numDistinct != numDistinctExpected) |
| return false; |
| |
| for (h = negativeMinNormal, toward = negativeInfinity, numDistinct = 0; |
| numDistinct < maxSteps && h != toward; numDistinct ++) { |
| h = nextafter(h, toward); |
| } |
| if (numDistinct != numDistinctExpected) |
| return false; |
| |
| for (h = negativeInfinity, toward = negativeMinNormal, numDistinct = 0; |
| numDistinct < maxSteps && h != toward; numDistinct ++) { |
| h = nextafter(h, toward); |
| } |
| if (numDistinct != numDistinctExpected) |
| return false; |
| |
| // Test nextafter at the boundary of subnormal numbers. Since RenderScript |
| // doesn't require implementations to handle FP16 subnormals correctly, |
| // allow nextafter to return a valid normal number that satisfies the |
| // constraints of nextafter. |
| |
| // nextafter(0, infinity) = minnormal or minsubnormal |
| h = nextafter(zero, infinity); |
| if (h != minSubNormal && h != minNormal) |
| return false; |
| h = nextafter(zero, negativeInfinity); |
| if (h != negativeMinSubNormal && h != negativeMinNormal) |
| return false; |
| |
| // nextafter(minNormal, negativeInfinity) = maxSubNormal or zero |
| h = nextafter(minNormal, negativeInfinity); |
| if (h != maxSubNormal && h != zero) |
| return false; |
| h = nextafter(negativeMinNormal, infinity); |
| if (h != negativeMaxSubNormal && h != negativeZero) |
| return false; |
| |
| return true; |
| } |
| |
| static bool testIlogb() { |
| bool failed = false; |
| |
| // Test ilogb for 0, +/- infininty and NaN |
| half infinity, negativeInfinity; |
| SET_HALF_WORD(infinity, 0x7c00); |
| SET_HALF_WORD(negativeInfinity, 0xfc00); |
| |
| _RS_ASSERT_EQU(ilogb((half) 0), 0x80000000); |
| _RS_ASSERT_EQU(ilogb((half) -0), 0x80000000); |
| _RS_ASSERT_EQU(ilogb(infinity), 0x7fffffff); |
| _RS_ASSERT_EQU(ilogb(negativeInfinity), 0x7fffffff); |
| _RS_ASSERT_EQU(ilogb(nan_half()), 0x7fffffff); |
| |
| // ilogb(2^n) = n. Test at the boundary on either side of 2^n. |
| // Don't test subnormal numbers as implementations are not expected to |
| // handle them. |
| _RS_ASSERT_EQU(ilogb((half) 0.24), -3); |
| _RS_ASSERT_EQU(ilogb((half) 0.26), -2); |
| _RS_ASSERT_EQU(ilogb((half) 0.49), -2); |
| _RS_ASSERT_EQU(ilogb((half) 0.51), -1); |
| _RS_ASSERT_EQU(ilogb((half) 0.99), -1); |
| _RS_ASSERT_EQU(ilogb((half) 1.01), 0); |
| _RS_ASSERT_EQU(ilogb((half) 1.99), 0); |
| _RS_ASSERT_EQU(ilogb((half) 2.01), 1); |
| _RS_ASSERT_EQU(ilogb((half) 1023), 9); |
| _RS_ASSERT_EQU(ilogb((half) 1025), 10); |
| |
| // Result is same irrespective of sign. |
| _RS_ASSERT_EQU(ilogb((half) -0.24), -3); |
| _RS_ASSERT_EQU(ilogb((half) -0.26), -2); |
| _RS_ASSERT_EQU(ilogb((half) -0.49), -2); |
| _RS_ASSERT_EQU(ilogb((half) -0.51), -1); |
| _RS_ASSERT_EQU(ilogb((half) -0.99), -1); |
| _RS_ASSERT_EQU(ilogb((half) -1.01), 0); |
| _RS_ASSERT_EQU(ilogb((half) -1.99), 0); |
| _RS_ASSERT_EQU(ilogb((half) -2.01), 1); |
| _RS_ASSERT_EQU(ilogb((half) -1023), 9); |
| _RS_ASSERT_EQU(ilogb((half) -1025), 10); |
| |
| return !failed; |
| } |
| |
| void testFp16Math() { |
| bool success = true; |
| |
| success &= testAPI(); |
| success &= testFrexp(); |
| success &= testModf(); |
| success &= testNextAfter(); |
| success &= testIlogb(); |
| |
| if (success) { |
| rsDebug("PASSED", 0); |
| } else { |
| rsDebug("FAILED", 0); |
| } |
| |
| if (success) { |
| rsSendToClientBlocking(RS_MSG_TEST_PASSED); |
| } else { |
| rsSendToClientBlocking(RS_MSG_TEST_FAILED); |
| } |
| } |
