am dfcf0655: am 09fd5a18: Merge "Replacing FloatMath native implementation with calls to Math" (1f2ad9eb) · Commits · e / os / android_frameworks_base

core/java/android/util/FloatMath.java

+31 −12

Original line number	Diff line number	Diff line
		@@ -17,10 +17,13 @@
		package android.util;

		/**
		* Math routines similar to those found in {@link java.lang.Math}. On
		* versions of Android with a JIT, these are significantly slower than
		* the equivalent {@code Math} functions, which should be used in preference
		* to these.
		* Math routines similar to those found in {@link java.lang.Math}.
		*
		* <p>Historically these methods were faster than the equivalent double-based
		* {@link java.lang.Math} methods. On versions of Android with a JIT they
		* became slower and have since been re-implemented to wrap calls to
		* {@link java.lang.Math}. {@link java.lang.Math} should be used in
		* preference.
		*/
		public class FloatMath {

		@@ -34,7 +37,9 @@ public class FloatMath {
		* @param value to be converted
		* @return the floor of value
		*/
		public static native float floor(float value);
		public static float floor(float value) {
		return (float) Math.floor(value);
		}

		/**
		* Returns the float conversion of the most negative (i.e. closest to
		@@ -43,7 +48,9 @@ public class FloatMath {
		* @param value to be converted
		* @return the ceiling of value
		*/
		public static native float ceil(float value);
		public static float ceil(float value) {
		return (float) Math.ceil(value);
		}

		/**
		* Returns the closest float approximation of the sine of the argument.
		@@ -51,7 +58,9 @@ public class FloatMath {
		* @param angle to compute the cosine of, in radians
		* @return the sine of angle
		*/
		public static native float sin(float angle);
		public static float sin(float angle) {
		return (float) Math.sin(angle);
		}

		/**
		* Returns the closest float approximation of the cosine of the argument.
		@@ -59,7 +68,9 @@ public class FloatMath {
		* @param angle to compute the cosine of, in radians
		* @return the cosine of angle
		*/
		public static native float cos(float angle);
		public static float cos(float angle) {
		return (float) Math.cos(angle);
		}

		/**
		* Returns the closest float approximation of the square root of the
		@@ -68,7 +79,9 @@ public class FloatMath {
		* @param value to compute sqrt of
		* @return the square root of value
		*/
		public static native float sqrt(float value);
		public static float sqrt(float value) {
		return (float) Math.sqrt(value);
		}

		/**
		* Returns the closest float approximation of the raising "e" to the power
		@@ -77,7 +90,9 @@ public class FloatMath {
		* @param value to compute the exponential of
		* @return the exponential of value
		*/
		public static native float exp(float value);
		public static float exp(float value) {
		return (float) Math.exp(value);
		}

		/**
		* Returns the closest float approximation of the result of raising {@code
		@@ -87,7 +102,9 @@ public class FloatMath {
		* @param y the exponent of the operation.
		* @return {@code x} to the power of {@code y}.
		*/
		public static native float pow(float x, float y);
		public static float pow(float x, float y) {
		return (float) Math.pow(x, y);
		}

		/**
		* Returns {@code sqrt(}<i>{@code x}</i><sup>{@code 2}</sup>{@code +} <i>
		@@ -97,5 +114,7 @@ public class FloatMath {
		* @param y a float number
		* @return the hypotenuse
		*/
		public static native float hypot(float x, float y);
		public static float hypot(float x, float y) {
		return (float) Math.hypot(x, y);
		}
		}

core/jni/Android.mk

+0 −1

Original line number	Diff line number	Diff line
		@@ -85,7 +85,6 @@ LOCAL_SRC_FILES:= \
		android_util_Binder.cpp \
		android_util_EventLog.cpp \
		android_util_Log.cpp \
		android_util_FloatMath.cpp \
		android_util_Process.cpp \
		android_util_StringBlock.cpp \
		android_util_XmlBlock.cpp \

core/jni/AndroidRuntime.cpp

+0 −3

Original line number	Diff line number	Diff line
		@@ -95,8 +95,6 @@ extern int register_android_media_AudioTrack(JNIEnv *env);
		extern int register_android_media_JetPlayer(JNIEnv *env);
		extern int register_android_media_ToneGenerator(JNIEnv *env);

		extern int register_android_util_FloatMath(JNIEnv* env);

		namespace android {

		/*
		@@ -1228,7 +1226,6 @@ static const RegJNIRec gRegJNI[] = {
		REG_JNI(register_android_os_SystemClock),
		REG_JNI(register_android_util_EventLog),
		REG_JNI(register_android_util_Log),
		REG_JNI(register_android_util_FloatMath),
		REG_JNI(register_android_content_AssetManager),
		REG_JNI(register_android_content_StringBlock),
		REG_JNI(register_android_content_XmlBlock),

core/jni/android_util_FloatMath.cpp

deleted100644 → 0

+0 −61

Original line number	Diff line number	Diff line
		#include "jni.h"
		#include <android_runtime/AndroidRuntime.h>
		#include <math.h>
		#include <float.h>
		#include "SkTypes.h"

		class MathUtilsGlue {
		public:
		static float FloorF(JNIEnv* env, jobject clazz, float x) {
		return floorf(x);
		}

		static float CeilF(JNIEnv* env, jobject clazz, float x) {
		return ceilf(x);
		}

		static float SinF(JNIEnv* env, jobject clazz, float x) {
		return sinf(x);
		}

		static float CosF(JNIEnv* env, jobject clazz, float x) {
		return cosf(x);
		}

		static float SqrtF(JNIEnv* env, jobject clazz, float x) {
		return sqrtf(x);
		}

		static float ExpF(JNIEnv* env, jobject clazz, float x) {
		return expf(x);
		}

		static float PowF(JNIEnv* env, jobject clazz, float x, float y) {
		return powf(x, y);
		}

		static float HypotF(JNIEnv* env, jobject clazz, float x, float y) {
		return hypotf(x, y);
		}
		};

		static JNINativeMethod gMathUtilsMethods[] = {
		{"floor", "(F)F", (void*) MathUtilsGlue::FloorF},
		{"ceil", "(F)F", (void*) MathUtilsGlue::CeilF},
		{"sin", "(F)F", (void*) MathUtilsGlue::SinF},
		{"cos", "(F)F", (void*) MathUtilsGlue::CosF},
		{"sqrt", "(F)F", (void*) MathUtilsGlue::SqrtF},
		{"exp", "(F)F", (void*) MathUtilsGlue::ExpF},
		{"pow", "(FF)F", (void*) MathUtilsGlue::PowF},
		{"hypot", "(FF)F", (void*) MathUtilsGlue::HypotF},
		};

		int register_android_util_FloatMath(JNIEnv* env)
		{
		int result = android::AndroidRuntime::registerNativeMethods(env,
		"android/util/FloatMath",
		gMathUtilsMethods,
		SK_ARRAY_COUNT(gMathUtilsMethods));
		return result;
		}

core/tests/benchmarks/src/android/util/FloatMathBenchmark.java

0 → 100644

+116 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2014 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.util;

		import com.google.caliper.Param;
		import com.google.caliper.Runner;
		import com.google.caliper.SimpleBenchmark;

		import android.util.FloatMath;

		public class FloatMathBenchmark extends SimpleBenchmark {

		public float timeFloatMathCeil(int reps) {
		// Keep an answer so we don't optimize the method call away.
		float f = 0.0f;
		for (int i = 0; i < reps; i++) {
		f += FloatMath.ceil(100.123f);
		}
		return f;
		}

		public float timeFloatMathCeil_math(int reps) {
		// Keep an answer so we don't optimize the method call away.
		float f = 0.0f;
		for (int i = 0; i < reps; i++) {
		f += (float) Math.ceil(100.123f);
		}
		return f;
		}

		public float timeFloatMathCos(int reps) {
		// Keep an answer so we don't optimize the method call away.
		float f = 0.0f;
		for (int i = 0; i < reps; i++) {
		f += FloatMath.cos(100.123f);
		}
		return f;
		}

		public float timeFloatMathExp(int reps) {
		// Keep an answer so we don't optimize the method call away.
		float f = 0.0f;
		for (int i = 0; i < reps; i++) {
		f += FloatMath.exp(100.123f);
		}
		return f;
		}

		public float timeFloatMathFloor(int reps) {
		// Keep an answer so we don't optimize the method call away.
		float f = 0.0f;
		for (int i = 0; i < reps; i++) {
		f += FloatMath.floor(100.123f);
		}
		return f;
		}

		public float timeFloatMathHypot(int reps) {
		// Keep an answer so we don't optimize the method call away.
		float f = 0.0f;
		for (int i = 0; i < reps; i++) {
		f += FloatMath.hypot(100.123f, 100.123f);
		}
		return f;
		}

		public float timeFloatMathPow(int reps) {
		// Keep an answer so we don't optimize the method call away.
		float f = 0.0f;
		for (int i = 0; i < reps; i++) {
		f += FloatMath.pow(10.123f, 10.123f);
		}
		return f;
		}

		public float timeFloatMathSin(int reps) {
		// Keep an answer so we don't optimize the method call away.
		float f = 0.0f;
		for (int i = 0; i < reps; i++) {
		f += FloatMath.sin(100.123f);
		}
		return f;
		}

		public float timeFloatMathSqrt(int reps) {
		// Keep an answer so we don't optimize the method call away.
		float f = 0.0f;
		for (int i = 0; i < reps; i++) {
		f += FloatMath.sqrt(100.123f);
		}
		return f;
		}

		public float timeFloatMathSqrt_math(int reps) {
		// Keep an answer so we don't optimize the method call away.
		float f = 0.0f;
		for (int i = 0; i < reps; i++) {
		f += (float) Math.sqrt(100.123f);
		}
		return f;
		}

		}