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