Merge "Add initialization check benchmark"

startop/apps/test/Android.bp

@@ -22,6 +22,8 @@ android_app {
         "src/CPUIntensiveBenchmarks.java",
         "src/EmptyActivity.java",
         "src/FrameLayoutInflationActivity.java",
+        "src/InitCheckOverheadBenchmarkActivity.java",
+        "src/InitCheckOverheadBenchmarks.java",
         "src/LayoutInflationActivity.java",
         "src/NonInteractiveSystemServerBenchmarkActivity.java",
         "src/SystemServerBenchmarkActivity.java",

startop/apps/test/AndroidManifest.xml

@@ -72,6 +72,18 @@
             </intent-filter>
         </activity>
 
+        <activity
+            android:label="Initialization Check Overhead Test"
+            android:name=".InitCheckOverheadBenchmarkActivity"
+            android:exported="true" >
+
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+
         <activity
             android:label="TextView Layout Test"
             android:name=".TextViewInflationActivity"

startop/apps/test/src/InitCheckOverheadBenchmarkActivity.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2019 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 com.android.startop.test;
+
+import android.os.Bundle;
+
+public class InitCheckOverheadBenchmarkActivity extends SystemServerBenchmarkActivity {
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.system_server_benchmark_page);
+
+        mBenchmarkList = findViewById(R.id.benchmark_list);
+
+        InitCheckOverheadBenchmarks.initializeBenchmarks(this, this);
+    }
+}

startop/apps/test/src/InitCheckOverheadBenchmarks.java

@@ -0,0 +1,134 @@
+/*
+ * Copyright (C) 2019 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.
+ */
+
+/**
+ *  A test of initialization check costs for AOT.
+ */
+
+package com.android.startop.test;
+
+import android.app.Activity;
+
+import java.util.Random;
+
+public class InitCheckOverheadBenchmarks {
+    public static int mSum;
+    public static int mSum2;
+    public static int mStep;
+    public static int mStep2;
+    public static int mStartingValue;
+
+    static {
+        Random random = new Random();
+        mStep = random.nextInt();
+        mStep2 = random.nextInt();
+        mStartingValue = random.nextInt();
+    };
+
+    static class OtherClass {
+        public static int mStep;
+        public static int mStep2;
+        public static int mStartingValue;
+        static {
+            Random random = new Random();
+            mStep = random.nextInt();
+            mStep2 = random.nextInt();
+            mStartingValue = random.nextInt();
+        };
+    };
+
+    public static void localStaticFor(int iterationCount) {
+        for (int i = 0; i < iterationCount; ++i) {
+            mSum += mStep;
+        }
+    }
+
+    public static void nonLocalStaticFor(int iterationCount) {
+        mSum = OtherClass.mStartingValue;
+        for (int i = 0; i < iterationCount; ++i) {
+            mSum += OtherClass.mStep;
+        }
+    }
+
+    public static void localStaticForTwo(int iterationCount) {
+        for (int i = 0; i < iterationCount; ++i) {
+            mSum += mStep;
+            mSum2 += mStep2;
+        }
+    }
+
+    public static void nonLocalStaticForTwo(int iterationCount) {
+        mSum = OtherClass.mStartingValue;
+        for (int i = 0; i < iterationCount; ++i) {
+            mSum += OtherClass.mStep;
+            mSum2 += OtherClass.mStep2;
+        }
+    }
+
+    public static void localStaticDoWhile(int iterationCount) {
+        int i = 0;
+        do {
+            mSum += mStep;
+            ++i;
+        } while (i < iterationCount);
+    }
+
+    public static void nonLocalStaticDoWhile(int iterationCount) {
+        mSum = OtherClass.mStartingValue;
+        int i = 0;
+        do {
+            mSum += OtherClass.mStep;
+            ++i;
+        } while (i < iterationCount);
+    }
+
+    public static void doGC() {
+        Runtime.getRuntime().gc();
+    }
+
+    // Time limit to run benchmarks in seconds
+    public static final int TIME_LIMIT = 5;
+
+    static void initializeBenchmarks(Activity parent, BenchmarkRunner benchmarks) {
+        benchmarks.addBenchmark("GC", () -> {
+            doGC();
+        });
+
+        benchmarks.addBenchmark("InitCheckFor (local)", () -> {
+            localStaticFor(10000000);
+        });
+
+        benchmarks.addBenchmark("InitCheckFor (non-local)", () -> {
+            nonLocalStaticFor(10000000);
+        });
+
+        benchmarks.addBenchmark("InitCheckForTwo (local)", () -> {
+            localStaticForTwo(10000000);
+        });
+
+        benchmarks.addBenchmark("InitCheckForTwo (non-local)", () -> {
+            nonLocalStaticForTwo(10000000);
+        });
+
+        benchmarks.addBenchmark("InitCheckDoWhile (local)", () -> {
+            localStaticDoWhile(10000000);
+        });
+
+        benchmarks.addBenchmark("InitCheckDoWhile (non-local)", () -> {
+            nonLocalStaticDoWhile(10000000);
+        });
+    }
+}