Replacing FloatMath native implementation with calls to Math (32b88b48) · Commits · e / os / android_frameworks_base

core/java/android/util/FloatMath.java

+7 −4

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

	/**		/**
	* Math routines similar to those found in {@link java.lang.Math}. On		* Math routines similar to those found in {@link java.lang.Math}.
	* versions of Android with a JIT, these are significantly slower than		*
	* the equivalent {@code Math} functions, which should be used in preference		* <p>Historically these methods were faster than the equivalent double-based
	* to these.		* {@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 {		public class FloatMath {

core/jni/Android.mk

+0 −1

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

core/jni/AndroidRuntime.cpp

+0 −3

Original line number	Original line	Diff line number	Diff line
	@@ -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_JetPlayer(JNIEnv *env);
	extern int register_android_media_ToneGenerator(JNIEnv *env);		extern int register_android_media_ToneGenerator(JNIEnv *env);

	extern int register_android_util_FloatMath(JNIEnv* env);

	namespace android {		namespace android {

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

core/jni/android_util_FloatMath.cpp

deleted100644 → 0

+0 −61

Original line number	Original line	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

+103 −0

Original line number	Original line	Diff line number	Diff line
			package android.util;

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

			import android.util.FloatMath;

			import dalvik.system.VMDebug;

			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;
			}

			}