test/545-tracing-and-jit/src/Main.java - LeafOS-Project/android_art - Gitiles

 /*
  * 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);
         }
     }
 }
	/*
	* 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);
	}
	}
	}