/*
|
* Copyright (C) 2010 Google Inc.
|
*
|
* 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 benchmarks.regression;
|
|
import java.lang.reflect.Constructor;
|
import java.lang.reflect.Field;
|
import java.lang.reflect.Method;
|
|
public class ReflectionBenchmark {
|
public void timeObject_getClass(int reps) throws Exception {
|
C c = new C();
|
for (int rep = 0; rep < reps; ++rep) {
|
c.getClass();
|
}
|
}
|
|
public void timeClass_getField(int reps) throws Exception {
|
Class<?> klass = C.class;
|
for (int rep = 0; rep < reps; ++rep) {
|
klass.getField("f");
|
}
|
}
|
|
public void timeClass_getDeclaredField(int reps) throws Exception {
|
Class<?> klass = C.class;
|
for (int rep = 0; rep < reps; ++rep) {
|
klass.getDeclaredField("f");
|
}
|
}
|
|
public void timeClass_getConstructor(int reps) throws Exception {
|
Class<?> klass = C.class;
|
for (int rep = 0; rep < reps; ++rep) {
|
klass.getConstructor();
|
}
|
}
|
|
public void timeClass_newInstance(int reps) throws Exception {
|
Class<?> klass = C.class;
|
Constructor constructor = klass.getConstructor();
|
for (int rep = 0; rep < reps; ++rep) {
|
constructor.newInstance();
|
}
|
}
|
|
public void timeClass_getMethod(int reps) throws Exception {
|
Class<?> klass = C.class;
|
for (int rep = 0; rep < reps; ++rep) {
|
klass.getMethod("m");
|
}
|
}
|
|
public void timeClass_getDeclaredMethod(int reps) throws Exception {
|
Class<?> klass = C.class;
|
for (int rep = 0; rep < reps; ++rep) {
|
klass.getDeclaredMethod("m");
|
}
|
}
|
|
public void timeField_setInt(int reps) throws Exception {
|
Class<?> klass = C.class;
|
Field f = klass.getDeclaredField("f");
|
C instance = new C();
|
for (int rep = 0; rep < reps; ++rep) {
|
f.setInt(instance, 1);
|
}
|
}
|
|
public void timeField_getInt(int reps) throws Exception {
|
Class<?> klass = C.class;
|
Field f = klass.getDeclaredField("f");
|
C instance = new C();
|
for (int rep = 0; rep < reps; ++rep) {
|
f.getInt(instance);
|
}
|
}
|
|
public void timeMethod_invokeV(int reps) throws Exception {
|
Class<?> klass = C.class;
|
Method m = klass.getDeclaredMethod("m");
|
C instance = new C();
|
for (int rep = 0; rep < reps; ++rep) {
|
m.invoke(instance);
|
}
|
}
|
|
public void timeMethod_invokeStaticV(int reps) throws Exception {
|
Class<?> klass = C.class;
|
Method m = klass.getDeclaredMethod("sm");
|
for (int rep = 0; rep < reps; ++rep) {
|
m.invoke(null);
|
}
|
}
|
|
public void timeMethod_invokeI(int reps) throws Exception {
|
Class<?> klass = C.class;
|
Method m = klass.getDeclaredMethod("setField", int.class);
|
C instance = new C();
|
for (int rep = 0; rep < reps; ++rep) {
|
m.invoke(instance, 1);
|
}
|
}
|
|
public void timeMethod_invokePreBoxedI(int reps) throws Exception {
|
Class<?> klass = C.class;
|
Method m = klass.getDeclaredMethod("setField", int.class);
|
C instance = new C();
|
Integer one = Integer.valueOf(1);
|
for (int rep = 0; rep < reps; ++rep) {
|
m.invoke(instance, one);
|
}
|
}
|
|
public void timeMethod_invokeStaticI(int reps) throws Exception {
|
Class<?> klass = C.class;
|
Method m = klass.getDeclaredMethod("setStaticField", int.class);
|
for (int rep = 0; rep < reps; ++rep) {
|
m.invoke(null, 1);
|
}
|
}
|
|
public void timeMethod_invokeStaticPreBoxedI(int reps) throws Exception {
|
Class<?> klass = C.class;
|
Method m = klass.getDeclaredMethod("setStaticField", int.class);
|
Integer one = Integer.valueOf(1);
|
for (int rep = 0; rep < reps; ++rep) {
|
m.invoke(null, one);
|
}
|
}
|
|
public void timeRegularMethodInvocation(int reps) throws Exception {
|
C instance = new C();
|
for (int rep = 0; rep < reps; ++rep) {
|
instance.setField(1);
|
}
|
}
|
|
public void timeRegularConstructor(int reps) throws Exception {
|
for (int rep = 0; rep < reps; ++rep) {
|
new C();
|
}
|
}
|
|
public void timeClass_classNewInstance(int reps) throws Exception {
|
Class<?> klass = C.class;
|
for (int rep = 0; rep < reps; ++rep) {
|
klass.newInstance();
|
}
|
}
|
|
public void timeClass_isInstance(int reps) throws Exception {
|
D d = new D();
|
Class<?> klass = IC.class;
|
for (int rep = 0; rep < reps; ++rep) {
|
klass.isInstance(d);
|
}
|
}
|
|
public void timeGetInstanceField(int reps) throws Exception {
|
for (int rep = 0; rep < reps; ++rep) {
|
// The field here (and in timeGetStaticField) were chosen to be
|
// ~75% down the bottom of the alphabetically sorted field list.
|
// It's hard to construct a "fair" test case without resorting to
|
// a class whose field names are created algorithmically.
|
//
|
// TODO: Write a test script that generates both the classes we're
|
// reflecting on and the test case for each of its fields.
|
R.class.getField("mtextAppearanceLargePopupMenu");
|
}
|
}
|
|
public void timeGetStaticField(int reps) throws Exception {
|
for (int rep = 0; rep < reps; ++rep) {
|
R.class.getField("weekNumberColor");
|
}
|
}
|
|
public void timeGetInterfaceStaticField(int reps) throws Exception {
|
for (int rep = 0; rep < reps; ++rep) {
|
F.class.getField("sf");
|
}
|
}
|
|
public void timeGetSuperClassField(int reps) throws Exception {
|
for (int rep = 0; rep < reps; ++rep) {
|
G.class.getField("f");
|
}
|
}
|
|
|
public static class C {
|
public static int sf = 0;
|
public int f = 0;
|
|
public C() {
|
// A non-empty constructor so we don't get optimized away.
|
f = 1;
|
}
|
|
public void m() {
|
}
|
|
public static void sm() {
|
}
|
|
public void setField(int value) {
|
f = value;
|
}
|
|
public static void setStaticField(int value) {
|
sf = value;
|
}
|
}
|
|
interface IA {
|
}
|
|
interface IB extends IA {
|
}
|
|
interface IC extends IB {
|
public static final int sf = 0;
|
}
|
|
class D implements IC {
|
}
|
|
class E extends D {
|
}
|
|
class F extends E implements IB {
|
}
|
|
class G extends C {
|
}
|
}
|
