Fix TODO on instrumentation and add some more DCHECKs.
bug:25343683
bug:25438583
Change-Id: I232deb1b6761466b514c687ce304f61928755cdc
diff --git a/test/545-tracing-and-jit/src/Main.java b/test/545-tracing-and-jit/src/Main.java
new file mode 100644
index 0000000..d3c79ae
--- /dev/null
+++ b/test/545-tracing-and-jit/src/Main.java
@@ -0,0 +1,242 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.Method;
+import java.util.concurrent.ConcurrentSkipListMap;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+public class Main {
+ private static final String TEMP_FILE_NAME_PREFIX = "test";
+ private static final String TEMP_FILE_NAME_SUFFIX = ".trace";
+ private static File file;
+
+ public static void main(String[] args) throws Exception {
+ String name = System.getProperty("java.vm.name");
+ if (!"Dalvik".equals(name)) {
+ System.out.println("This test is not supported on " + name);
+ return;
+ }
+ file = createTempFile();
+ try {
+ new Main().ensureCaller(true, 0);
+ new Main().ensureCaller(false, 0);
+ } finally {
+ if (file != null) {
+ file.delete();
+ }
+ }
+ }
+
+ private static File createTempFile() throws Exception {
+ try {
+ return File.createTempFile(TEMP_FILE_NAME_PREFIX, TEMP_FILE_NAME_SUFFIX);
+ } catch (IOException e) {
+ System.setProperty("java.io.tmpdir", "/data/local/tmp");
+ try {
+ return File.createTempFile(TEMP_FILE_NAME_PREFIX, TEMP_FILE_NAME_SUFFIX);
+ } catch (IOException e2) {
+ System.setProperty("java.io.tmpdir", "/sdcard");
+ return File.createTempFile(TEMP_FILE_NAME_PREFIX, TEMP_FILE_NAME_SUFFIX);
+ }
+ }
+ }
+
+ // We make sure 'doLoadsOfStuff' has a caller, because it is this caller that will be
+ // pushed in the side instrumentation frame.
+ public void ensureCaller(boolean warmup, int invocationCount) throws Exception {
+ doLoadsOfStuff(warmup, invocationCount);
+ }
+
+ // The number of recursive calls we are going to do in 'doLoadsOfStuff' to ensure
+ // the JIT sees it hot.
+ static final int NUMBER_OF_INVOCATIONS = 5;
+
+ public void doLoadsOfStuff(boolean warmup, int invocationCount) throws Exception {
+ // Warmup is to make sure the JIT gets a chance to compile 'doLoadsOfStuff'.
+ if (warmup) {
+ if (invocationCount < NUMBER_OF_INVOCATIONS) {
+ doLoadsOfStuff(warmup, ++invocationCount);
+ } else {
+ // Give the JIT a chance to compiler.
+ Thread.sleep(1000);
+ }
+ } else {
+ if (invocationCount == 0) {
+ VMDebug.startMethodTracing(file.getPath(), 0, 0, false, 0);
+ }
+ fillJit();
+ if (invocationCount < NUMBER_OF_INVOCATIONS) {
+ doLoadsOfStuff(warmup, ++invocationCount);
+ } else {
+ VMDebug.stopMethodTracing();
+ }
+ }
+ }
+
+ // This method creates enough profiling data to fill the code cache and trigger
+ // a collection in debug mode (at the time of the test 10KB of data space). We
+ // used to crash by not looking at the instrumentation stack and deleting JIT code
+ // that will be later restored by the instrumentation.
+ public static void fillJit() throws Exception {
+ Map map = new HashMap();
+ map.put("foo", "bar");
+ map.clear();
+ map.containsKey("foo");
+ map.containsValue("foo");
+ map.entrySet();
+ map.equals(map);
+ map.hashCode();
+ map.isEmpty();
+ map.keySet();
+ map.putAll(map);
+ map.remove("foo");
+ map.size();
+ map.put("bar", "foo");
+ map.values();
+
+ map = new LinkedHashMap();
+ map.put("foo", "bar");
+ map.clear();
+ map.containsKey("foo");
+ map.containsValue("foo");
+ map.entrySet();
+ map.equals(map);
+ map.hashCode();
+ map.isEmpty();
+ map.keySet();
+ map.putAll(map);
+ map.remove("foo");
+ map.size();
+ map.put("bar", "foo");
+ map.values();
+
+ map = new TreeMap();
+ map.put("foo", "bar");
+ map.clear();
+ map.containsKey("foo");
+ map.containsValue("foo");
+ map.entrySet();
+ map.equals(map);
+ map.hashCode();
+ map.isEmpty();
+ map.keySet();
+ map.putAll(map);
+ map.remove("foo");
+ map.size();
+ map.put("bar", "foo");
+ map.values();
+
+ map = new ConcurrentSkipListMap();
+ map.put("foo", "bar");
+ map.clear();
+ map.containsKey("foo");
+ map.containsValue("foo");
+ map.entrySet();
+ map.equals(map);
+ map.hashCode();
+ map.isEmpty();
+ map.keySet();
+ map.putAll(map);
+ map.remove("foo");
+ map.size();
+ map.put("bar", "foo");
+ map.values();
+
+ Set set = new HashSet();
+ set.add("foo");
+ set.addAll(set);
+ set.clear();
+ set.contains("foo");
+ set.containsAll(set);
+ set.equals(set);
+ set.hashCode();
+ set.isEmpty();
+ set.iterator();
+ set.remove("foo");
+ set.removeAll(set);
+ set.retainAll(set);
+ set.size();
+ set.add("foo");
+ set.toArray();
+
+ set = new LinkedHashSet();
+ set.add("foo");
+ set.addAll(set);
+ set.clear();
+ set.contains("foo");
+ set.containsAll(set);
+ set.equals(set);
+ set.hashCode();
+ set.isEmpty();
+ set.iterator();
+ set.remove("foo");
+ set.removeAll(set);
+ set.retainAll(set);
+ set.size();
+ set.add("foo");
+ set.toArray();
+
+ set = new TreeSet();
+ set.add("foo");
+ set.addAll(set);
+ set.clear();
+ set.contains("foo");
+ set.containsAll(set);
+ set.equals(set);
+ set.hashCode();
+ set.isEmpty();
+ set.iterator();
+ set.remove("foo");
+ set.removeAll(set);
+ set.retainAll(set);
+ set.size();
+ set.add("foo");
+ set.toArray();
+ }
+
+ private static class VMDebug {
+ private static final Method startMethodTracingMethod;
+ private static final Method stopMethodTracingMethod;
+ static {
+ try {
+ Class c = Class.forName("dalvik.system.VMDebug");
+ startMethodTracingMethod = c.getDeclaredMethod("startMethodTracing", String.class,
+ Integer.TYPE, Integer.TYPE, Boolean.TYPE, Integer.TYPE);
+ stopMethodTracingMethod = c.getDeclaredMethod("stopMethodTracing");
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ public static void startMethodTracing(String filename, int bufferSize, int flags,
+ boolean samplingEnabled, int intervalUs) throws Exception {
+ startMethodTracingMethod.invoke(null, filename, bufferSize, flags, samplingEnabled,
+ intervalUs);
+ }
+ public static void stopMethodTracing() throws Exception {
+ stopMethodTracingMethod.invoke(null);
+ }
+ }
+}