tests/tests/renderscript/src/android/renderscript/cts/Float16ArithmeticTest.java - platform/cts - Git at Google

 /*
  * Copyright (C) 2015 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package android.renderscript.cts;

 import java.util.Random;
 import java.lang.Math;
 import java.lang.Float;
 import java.lang.Integer;
 import java.lang.Short;

 import android.content.Context;
 import android.content.res.Resources;
 import android.renderscript.Allocation;
 import android.renderscript.Element;
 import android.renderscript.RenderScript;
 import android.renderscript.RSRuntimeException;
 import android.renderscript.Script;
 import android.renderscript.Type;
 import android.util.Log;

 public class Float16ArithmeticTest extends RSBaseCompute {
     private int numInputs = Float16TestData.input.length;

     // Allocations to hold float16 input and output
     private Allocation mInput;
     private Allocation mF16Matrix;
     private Allocation mU16Matrix;

     // A numInputs * numInputs length 1-D array with data copied from
     // mU16Matrix
     private short[] output = new short[numInputs * numInputs];

     // 16-bit masks for extracting sign, exponent and mantissa bits
     private static short SIGN_MASK     = (short) 0x8000;
     private static short EXPONENT_MASK = (short) 0x7C00;
     private static short MANTISSA_MASK = (short) 0x03FF;

     // NaN has all exponent bits set to 1 and a non-zero mantissa
     private boolean isFloat16NaN(short val) {
         return (val & EXPONENT_MASK) == EXPONENT_MASK &&
                (val & MANTISSA_MASK) != 0;
     }

     // Infinity has all exponent bits set to 1 and zeroes in mantissa
     private boolean isFloat16Infinite(short val) {
         return (val & EXPONENT_MASK) == EXPONENT_MASK &&
                (val & MANTISSA_MASK) == 0;
     }

     // Subnormal numbers have exponent bits set to 0 and a non-zero mantissa
     private boolean isFloat16SubNormal(short val) {
         return (val & EXPONENT_MASK) == 0 && (val & MANTISSA_MASK) != 0;
     }

     // Zero has all but the sign bit set to zero
     private boolean isFloat16Zero(short val) {
         return (val & ~SIGN_MASK) == 0;
     }

     // Negativity test checks the sign bit
     private boolean isFloat16Negative(short val) {
         return (val & SIGN_MASK) != 0;
     }

     // Check if this is a finite, non-zero FP16 value
     private boolean isFloat16FiniteNonZero(short val) {
         return !isFloat16NaN(val) && !isFloat16Infinite(val) && !isFloat16Zero(val);
     }

     // Convert FP16 value to float
     private float convertFloat16ToFloat(short val) {
         // Extract sign, exponent and mantissa
         int sign = val & SIGN_MASK;
         int exponent = (val & EXPONENT_MASK) >> 10;
         int mantissa = val & MANTISSA_MASK;

         // 0.<mantissa> = <mantissa> * 2^-10
         float mantissaAsFloat = Math.scalb(mantissa, -10);

         float result;
         if (isFloat16Zero(val))
             result = 0.0f;
         else if (isFloat16Infinite(val))
             result = java.lang.Float.POSITIVE_INFINITY;
         else if (isFloat16NaN(val))
             result = java.lang.Float.NaN;
         else if (isFloat16SubNormal(val)) {
             // value is 2^-14 * mantissaAsFloat
             result = Math.scalb(1, -14) * mantissaAsFloat;
         }
         else {
             // value is 2^(exponent - 15) * 1.<mantissa>
             result = Math.scalb(1, exponent - 15) * (1 + mantissaAsFloat);
         }

         if (sign != 0)
             result = -result;
         return result;
     }

     // Create input, intermediate, and output allocations.  Copy input data to
     // the input allocation
     private void setupTest() {
         Element f16 = Element.F16(mRS);
         Element u16 = Element.U16(mRS);
         Type f16Matrix = Type.createXY(mRS, f16, numInputs, numInputs);
         Type u16Matrix = Type.createXY(mRS, u16, numInputs, numInputs);

         mInput = Allocation.createSized(mRS, f16, numInputs);
         mF16Matrix = Allocation.createTyped(mRS, f16Matrix);
         mU16Matrix = Allocation.createTyped(mRS, u16Matrix);

         mInput.copyFromUnchecked(Float16TestData.input);
     }

     // Check the output of performing 'operation' on inputs x and y against the
     // reference output in refValues.  For special cases like Infinity, NaN and
     // zero, use exact comparison.  Otherwise, check if the output is within
     // the bounds in 'refValues' by converting all values to float.
     private boolean checkFloat16Output(int x, int y, short[][][] refValues,
                                        String operation)
     {
         // Find the input, output and reference values based on the indices
         short in1 = Float16TestData.input[x];
         short in2 = Float16TestData.input[y];
         short out = output[x + y * numInputs];
         short lb = refValues[x][y][0];
         short ub = refValues[x][y][1];

         // Do exact match if the reference value is a special case (Nan, zero
         // infinity or their negative equivalents).
         if (isFloat16Infinite(lb))
             return lb == out;
         // NaN can have any non-zero mantissa.  Do not use equality check
         if (isFloat16NaN(lb))
             return isFloat16NaN(out);
         // If reference output is zero, test for exact equivalence if at least
         // one of the input values is a special-case FP16 value.
         if (isFloat16Zero(lb)) {
             if (!isFloat16FiniteNonZero(in1) || !isFloat16FiniteNonZero(in2))
                 return lb == out;
         }

         float floatLB = convertFloat16ToFloat(lb);
         float floatUB = convertFloat16ToFloat(ub);
         float floatOut = convertFloat16ToFloat(out);

         if (floatOut < floatLB || floatOut > floatUB) {
             StringBuilder message = new StringBuilder();
             message.append("Incorrect output for float16 " + operation + ":");
             message.append("\nInput 1: " + Short.toString(in1));
             message.append("\nInput 2: " + Short.toString(in2));
             message.append("\nExpected output between: " + Short.toString(lb) +
                            " and " + Short.toString(ub));
             message.append("\nActual   output: " + Short.toString(out));
             message.append("\nExpected output (in float) between: " +
                            Float.toString(floatLB) + " and " + Float.toString(floatUB));
             message.append("\nActual   output: " + Float.toString(floatOut));
             assertTrue(message.toString(), false);
         }
         return true;
     }

     private boolean checkFloat16Add(int x, int y) {
         return checkFloat16Output(x, y, Float16TestData.ReferenceOutputForAdd,
                                   "addition");
     }

     public void testFloat16Add() {
         setupTest();
         ScriptC_float16_arithmetic script = new ScriptC_float16_arithmetic(mRS);

         script.set_gInput(mInput);
         script.forEach_add(mF16Matrix);
         script.forEach_bitcast(mF16Matrix, mU16Matrix);
         mU16Matrix.copyTo(output);

         for (int x = 0; x < numInputs; x ++) {
             for (int y = 0; y < numInputs; y ++) {
                 checkFloat16Add(x, y);
             }
         }
     }

     private boolean checkFloat16Sub(int x, int y) {
         return checkFloat16Output(x, y, Float16TestData.ReferenceOutputForSub,
                                   "subtraction");
     }

     public void testFloat16Sub() {
         setupTest();
         ScriptC_float16_arithmetic script = new ScriptC_float16_arithmetic(mRS);

         script.set_gInput(mInput);
         script.forEach_sub(mF16Matrix);
         script.forEach_bitcast(mF16Matrix, mU16Matrix);
         mU16Matrix.copyTo(output);

         for (int x = 0; x < numInputs; x ++) {
             for (int y = 0; y < numInputs; y ++) {
                 checkFloat16Sub(x, y);
             }
         }
     }

     private boolean checkFloat16Mul(int x, int y) {
         return checkFloat16Output(x, y, Float16TestData.ReferenceOutputForMul,
                                   "multiplication");
     }

     public void testFloat16Mul() {
         setupTest();
         ScriptC_float16_arithmetic script = new ScriptC_float16_arithmetic(mRS);

         script.set_gInput(mInput);
         script.forEach_mul(mF16Matrix);
         script.forEach_bitcast(mF16Matrix, mU16Matrix);
         mU16Matrix.copyTo(output);

         for (int x = 0; x < numInputs; x ++) {
             for (int y = 0; y < numInputs; y ++) {
                 checkFloat16Mul(x, y);
             }
         }
     }

     private boolean checkFloat16Div(int x, int y) {
         return checkFloat16Output(x, y, Float16TestData.ReferenceOutputForDiv,
                                   "division");
     }

     public void testFloat16Div() {
         setupTest();
         ScriptC_float16_arithmetic script = new ScriptC_float16_arithmetic(mRS);

         script.set_gInput(mInput);
         script.forEach_div(mF16Matrix);
         script.forEach_bitcast(mF16Matrix, mU16Matrix);
         mU16Matrix.copyTo(output);

         for (int x = 0; x < numInputs; x ++) {
             for (int y = 0; y < numInputs; y ++) {
                 checkFloat16Div(x, y);
             }
         }
     }
 }
	/*
	* Copyright (C) 2015 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package android.renderscript.cts;

	import java.util.Random;
	import java.lang.Math;
	import java.lang.Float;
	import java.lang.Integer;
	import java.lang.Short;

	import android.content.Context;
	import android.content.res.Resources;
	import android.renderscript.Allocation;
	import android.renderscript.Element;
	import android.renderscript.RenderScript;
	import android.renderscript.RSRuntimeException;
	import android.renderscript.Script;
	import android.renderscript.Type;
	import android.util.Log;

	public class Float16ArithmeticTest extends RSBaseCompute {
	private int numInputs = Float16TestData.input.length;

	// Allocations to hold float16 input and output
	private Allocation mInput;
	private Allocation mF16Matrix;
	private Allocation mU16Matrix;

	// A numInputs * numInputs length 1-D array with data copied from
	// mU16Matrix
	private short[] output = new short[numInputs * numInputs];

	// 16-bit masks for extracting sign, exponent and mantissa bits
	private static short SIGN_MASK = (short) 0x8000;
	private static short EXPONENT_MASK = (short) 0x7C00;
	private static short MANTISSA_MASK = (short) 0x03FF;

	// NaN has all exponent bits set to 1 and a non-zero mantissa
	private boolean isFloat16NaN(short val) {
	return (val & EXPONENT_MASK) == EXPONENT_MASK &&
	(val & MANTISSA_MASK) != 0;
	}

	// Infinity has all exponent bits set to 1 and zeroes in mantissa
	private boolean isFloat16Infinite(short val) {
	return (val & EXPONENT_MASK) == EXPONENT_MASK &&
	(val & MANTISSA_MASK) == 0;
	}

	// Subnormal numbers have exponent bits set to 0 and a non-zero mantissa
	private boolean isFloat16SubNormal(short val) {
	return (val & EXPONENT_MASK) == 0 && (val & MANTISSA_MASK) != 0;
	}

	// Zero has all but the sign bit set to zero
	private boolean isFloat16Zero(short val) {
	return (val & ~SIGN_MASK) == 0;
	}

	// Negativity test checks the sign bit
	private boolean isFloat16Negative(short val) {
	return (val & SIGN_MASK) != 0;
	}

	// Check if this is a finite, non-zero FP16 value
	private boolean isFloat16FiniteNonZero(short val) {
	return !isFloat16NaN(val) && !isFloat16Infinite(val) && !isFloat16Zero(val);
	}

	// Convert FP16 value to float
	private float convertFloat16ToFloat(short val) {
	// Extract sign, exponent and mantissa
	int sign = val & SIGN_MASK;
	int exponent = (val & EXPONENT_MASK) >> 10;
	int mantissa = val & MANTISSA_MASK;

	// 0.<mantissa> = <mantissa> * 2^-10
	float mantissaAsFloat = Math.scalb(mantissa, -10);

	float result;
	if (isFloat16Zero(val))
	result = 0.0f;
	else if (isFloat16Infinite(val))
	result = java.lang.Float.POSITIVE_INFINITY;
	else if (isFloat16NaN(val))
	result = java.lang.Float.NaN;
	else if (isFloat16SubNormal(val)) {
	// value is 2^-14 * mantissaAsFloat
	result = Math.scalb(1, -14) * mantissaAsFloat;
	}
	else {
	// value is 2^(exponent - 15) * 1.<mantissa>
	result = Math.scalb(1, exponent - 15) * (1 + mantissaAsFloat);
	}

	if (sign != 0)
	result = -result;
	return result;
	}

	// Create input, intermediate, and output allocations. Copy input data to
	// the input allocation
	private void setupTest() {
	Element f16 = Element.F16(mRS);
	Element u16 = Element.U16(mRS);
	Type f16Matrix = Type.createXY(mRS, f16, numInputs, numInputs);
	Type u16Matrix = Type.createXY(mRS, u16, numInputs, numInputs);

	mInput = Allocation.createSized(mRS, f16, numInputs);
	mF16Matrix = Allocation.createTyped(mRS, f16Matrix);
	mU16Matrix = Allocation.createTyped(mRS, u16Matrix);

	mInput.copyFromUnchecked(Float16TestData.input);
	}

	// Check the output of performing 'operation' on inputs x and y against the
	// reference output in refValues. For special cases like Infinity, NaN and
	// zero, use exact comparison. Otherwise, check if the output is within
	// the bounds in 'refValues' by converting all values to float.
	private boolean checkFloat16Output(int x, int y, short[][][] refValues,
	String operation)
	{
	// Find the input, output and reference values based on the indices
	short in1 = Float16TestData.input[x];
	short in2 = Float16TestData.input[y];
	short out = output[x + y * numInputs];
	short lb = refValues[x][y][0];
	short ub = refValues[x][y][1];

	// Do exact match if the reference value is a special case (Nan, zero
	// infinity or their negative equivalents).
	if (isFloat16Infinite(lb))
	return lb == out;
	// NaN can have any non-zero mantissa. Do not use equality check
	if (isFloat16NaN(lb))
	return isFloat16NaN(out);
	// If reference output is zero, test for exact equivalence if at least
	// one of the input values is a special-case FP16 value.
	if (isFloat16Zero(lb)) {
	if (!isFloat16FiniteNonZero(in1) \|\| !isFloat16FiniteNonZero(in2))
	return lb == out;
	}

	float floatLB = convertFloat16ToFloat(lb);
	float floatUB = convertFloat16ToFloat(ub);
	float floatOut = convertFloat16ToFloat(out);

	if (floatOut < floatLB \|\| floatOut > floatUB) {
	StringBuilder message = new StringBuilder();
	message.append("Incorrect output for float16 " + operation + ":");
	message.append("\nInput 1: " + Short.toString(in1));
	message.append("\nInput 2: " + Short.toString(in2));
	message.append("\nExpected output between: " + Short.toString(lb) +
	" and " + Short.toString(ub));
	message.append("\nActual output: " + Short.toString(out));
	message.append("\nExpected output (in float) between: " +
	Float.toString(floatLB) + " and " + Float.toString(floatUB));
	message.append("\nActual output: " + Float.toString(floatOut));
	assertTrue(message.toString(), false);
	}
	return true;
	}

	private boolean checkFloat16Add(int x, int y) {
	return checkFloat16Output(x, y, Float16TestData.ReferenceOutputForAdd,
	"addition");
	}

	public void testFloat16Add() {
	setupTest();
	ScriptC_float16_arithmetic script = new ScriptC_float16_arithmetic(mRS);

	script.set_gInput(mInput);
	script.forEach_add(mF16Matrix);
	script.forEach_bitcast(mF16Matrix, mU16Matrix);
	mU16Matrix.copyTo(output);

	for (int x = 0; x < numInputs; x ++) {
	for (int y = 0; y < numInputs; y ++) {
	checkFloat16Add(x, y);
	}
	}
	}

	private boolean checkFloat16Sub(int x, int y) {
	return checkFloat16Output(x, y, Float16TestData.ReferenceOutputForSub,
	"subtraction");
	}

	public void testFloat16Sub() {
	setupTest();
	ScriptC_float16_arithmetic script = new ScriptC_float16_arithmetic(mRS);

	script.set_gInput(mInput);
	script.forEach_sub(mF16Matrix);
	script.forEach_bitcast(mF16Matrix, mU16Matrix);
	mU16Matrix.copyTo(output);

	for (int x = 0; x < numInputs; x ++) {
	for (int y = 0; y < numInputs; y ++) {
	checkFloat16Sub(x, y);
	}
	}
	}

	private boolean checkFloat16Mul(int x, int y) {
	return checkFloat16Output(x, y, Float16TestData.ReferenceOutputForMul,
	"multiplication");
	}

	public void testFloat16Mul() {
	setupTest();
	ScriptC_float16_arithmetic script = new ScriptC_float16_arithmetic(mRS);

	script.set_gInput(mInput);
	script.forEach_mul(mF16Matrix);
	script.forEach_bitcast(mF16Matrix, mU16Matrix);
	mU16Matrix.copyTo(output);

	for (int x = 0; x < numInputs; x ++) {
	for (int y = 0; y < numInputs; y ++) {
	checkFloat16Mul(x, y);
	}
	}
	}

	private boolean checkFloat16Div(int x, int y) {
	return checkFloat16Output(x, y, Float16TestData.ReferenceOutputForDiv,
	"division");
	}

	public void testFloat16Div() {
	setupTest();
	ScriptC_float16_arithmetic script = new ScriptC_float16_arithmetic(mRS);

	script.set_gInput(mInput);
	script.forEach_div(mF16Matrix);
	script.forEach_bitcast(mF16Matrix, mU16Matrix);
	mU16Matrix.copyTo(output);

	for (int x = 0; x < numInputs; x ++) {
	for (int y = 0; y < numInputs; y ++) {
	checkFloat16Div(x, y);
	}
	}
	}
	}