blob: f365c6e6fd2b58c8224822f16f24d0bf74d12264 [file] [log] [blame]
/*
* 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) {
// When running the trace in trace mode, there is already a trace running.
if (VMDebug.getMethodTracingMode() != 0) {
VMDebug.stopMethodTracing();
}
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;
private static final Method getMethodTracingModeMethod;
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");
getMethodTracingModeMethod = c.getDeclaredMethod("getMethodTracingMode");
} 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);
}
public static int getMethodTracingMode() throws Exception {
return (int) getMethodTracingModeMethod.invoke(null);
}
}
}