diff --git a/core/java/android/util/FloatMath.java b/core/java/android/util/FloatMath.java index 0ffd5bd610982..90e0636b10c95 100644 --- a/core/java/android/util/FloatMath.java +++ b/core/java/android/util/FloatMath.java @@ -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}. + * + *

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(}{@code x}{@code 2}{@code +} @@ -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); + } } diff --git a/core/jni/Android.mk b/core/jni/Android.mk index 5d10f3c6404cf..9b3b09111a44c 100644 --- a/core/jni/Android.mk +++ b/core/jni/Android.mk @@ -80,7 +80,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 \ diff --git a/core/jni/AndroidRuntime.cpp b/core/jni/AndroidRuntime.cpp index 0d2cdb9ab1713..796a0c3039f92 100644 --- a/core/jni/AndroidRuntime.cpp +++ b/core/jni/AndroidRuntime.cpp @@ -90,8 +90,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 { /* @@ -1229,7 +1227,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), diff --git a/core/jni/android_util_FloatMath.cpp b/core/jni/android_util_FloatMath.cpp deleted file mode 100644 index 73b7a6fc310c1..0000000000000 --- a/core/jni/android_util_FloatMath.cpp +++ /dev/null @@ -1,61 +0,0 @@ -#include "jni.h" -#include -#include -#include -#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; -} - diff --git a/core/tests/benchmarks/src/android/util/FloatMathBenchmark.java b/core/tests/benchmarks/src/android/util/FloatMathBenchmark.java new file mode 100644 index 0000000000000..2858128b3c8d9 --- /dev/null +++ b/core/tests/benchmarks/src/android/util/FloatMathBenchmark.java @@ -0,0 +1,116 @@ +/* + * 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; + } + +}