xref: /libcore/benchmarks/src/benchmarks/regression/ReflectionBenchmark.java

/*
 * 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 {
    }
}