feat(jdk8): move files to new folder to avoid resources compiled.

jdkSrc/jdk8/sun/management/HotspotCompilation.java

@@ -0,0 +1,234 @@
+/*
+ * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package sun.management;
+
+import java.util.regex.*;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Iterator;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.TreeMap;
+import sun.management.counter.*;
+
+/**
+ * Implementation class of HotspotCompilationMBean interface.
+ *
+ * Internal, uncommitted management interface for Hotspot compilation
+ * system.
+ *
+ */
+class HotspotCompilation
+    implements HotspotCompilationMBean {
+
+    private VMManagement jvm;
+
+    /**
+     * Constructor of HotspotRuntime class.
+     */
+    HotspotCompilation(VMManagement vm) {
+        jvm = vm;
+        initCompilerCounters();
+    }
+
+    // Performance counter support
+    private static final String JAVA_CI    = "java.ci.";
+    private static final String COM_SUN_CI = "com.sun.ci.";
+    private static final String SUN_CI     = "sun.ci.";
+    private static final String CI_COUNTER_NAME_PATTERN =
+        JAVA_CI + "|" + COM_SUN_CI + "|" + SUN_CI;
+
+    private LongCounter compilerThreads;
+    private LongCounter totalCompiles;
+    private LongCounter totalBailouts;
+    private LongCounter totalInvalidates;
+    private LongCounter nmethodCodeSize;
+    private LongCounter nmethodSize;
+    private StringCounter lastMethod;
+    private LongCounter lastSize;
+    private LongCounter lastType;
+    private StringCounter lastFailedMethod;
+    private LongCounter lastFailedType;
+    private StringCounter lastInvalidatedMethod;
+    private LongCounter lastInvalidatedType;
+
+    private class CompilerThreadInfo {
+        int index;
+        String name;
+        StringCounter method;
+        LongCounter type;
+        LongCounter compiles;
+        LongCounter time;
+        CompilerThreadInfo(String bname, int index) {
+            String basename = bname + "." + index + ".";
+            this.name = bname + "-" + index;
+            this.method = (StringCounter) lookup(basename + "method");
+            this.type = (LongCounter) lookup(basename + "type");
+            this.compiles = (LongCounter) lookup(basename + "compiles");
+            this.time = (LongCounter) lookup(basename + "time");
+        }
+        CompilerThreadInfo(String bname) {
+            String basename = bname + ".";
+            this.name = bname;
+            this.method = (StringCounter) lookup(basename + "method");
+            this.type = (LongCounter) lookup(basename + "type");
+            this.compiles = (LongCounter) lookup(basename + "compiles");
+            this.time = (LongCounter) lookup(basename + "time");
+        }
+
+        CompilerThreadStat getCompilerThreadStat() {
+            MethodInfo minfo = new MethodInfo(method.stringValue(),
+                                              (int) type.longValue(),
+                                              -1);
+            return new CompilerThreadStat(name,
+                                          compiles.longValue(),
+                                          time.longValue(),
+                                          minfo);
+        }
+    }
+    private CompilerThreadInfo[] threads;
+    private int numActiveThreads; // number of active compiler threads
+
+    private Map<String, Counter> counters;
+    private Counter lookup(String name) {
+        Counter c = null;
+
+        // Only one counter exists with the specified name in the
+        // current implementation.  We first look up in the SUN_CI namespace
+        // since most counters are in SUN_CI namespace.
+
+        if ((c = counters.get(SUN_CI + name)) != null) {
+            return c;
+        }
+        if ((c = counters.get(COM_SUN_CI + name)) != null) {
+            return c;
+        }
+        if ((c = counters.get(JAVA_CI + name)) != null) {
+            return c;
+        }
+
+        // FIXME: should tolerate if counter doesn't exist
+        throw new AssertionError("Counter " + name + " does not exist");
+    }
+
+    private void initCompilerCounters() {
+        // Build a tree map of the current list of performance counters
+        counters = new TreeMap<>();
+        for (Counter c: getInternalCompilerCounters()) {
+            counters.put(c.getName(), c);
+        }
+
+        compilerThreads = (LongCounter) lookup("threads");
+        totalCompiles = (LongCounter) lookup("totalCompiles");
+        totalBailouts = (LongCounter) lookup("totalBailouts");
+        totalInvalidates = (LongCounter) lookup("totalInvalidates");
+        nmethodCodeSize = (LongCounter) lookup("nmethodCodeSize");
+        nmethodSize = (LongCounter) lookup("nmethodSize");
+        lastMethod = (StringCounter) lookup("lastMethod");
+        lastSize = (LongCounter) lookup("lastSize");
+        lastType = (LongCounter) lookup("lastType");
+        lastFailedMethod = (StringCounter) lookup("lastFailedMethod");
+        lastFailedType = (LongCounter) lookup("lastFailedType");
+        lastInvalidatedMethod = (StringCounter) lookup("lastInvalidatedMethod");
+        lastInvalidatedType = (LongCounter) lookup("lastInvalidatedType");
+
+        numActiveThreads = (int) compilerThreads.longValue();
+
+        // Allocate CompilerThreadInfo for compilerThread and adaptorThread
+        threads = new CompilerThreadInfo[numActiveThreads+1];
+
+        // AdaptorThread has index 0
+        if (counters.containsKey(SUN_CI + "adapterThread.compiles")) {
+            threads[0] = new CompilerThreadInfo("adapterThread", 0);
+            numActiveThreads++;
+        } else {
+            threads[0] = null;
+        }
+
+        for (int i = 1; i < threads.length; i++) {
+            threads[i] = new CompilerThreadInfo("compilerThread", i-1);
+        }
+    }
+
+    public int getCompilerThreadCount() {
+        return numActiveThreads;
+    }
+
+    public long getTotalCompileCount() {
+        return totalCompiles.longValue();
+    }
+
+    public long getBailoutCompileCount() {
+        return totalBailouts.longValue();
+    }
+
+    public long getInvalidatedCompileCount() {
+        return totalInvalidates.longValue();
+    }
+
+    public long getCompiledMethodCodeSize() {
+        return nmethodCodeSize.longValue();
+    }
+
+    public long getCompiledMethodSize() {
+        return nmethodSize.longValue();
+    }
+
+    public java.util.List<CompilerThreadStat> getCompilerThreadStats() {
+        List<CompilerThreadStat> list = new ArrayList<>(threads.length);
+        int i = 0;
+        if (threads[0] == null) {
+            // no adaptor thread
+            i = 1;
+        }
+        for (; i < threads.length; i++) {
+            list.add(threads[i].getCompilerThreadStat());
+        }
+        return list;
+    }
+
+    public MethodInfo getLastCompile() {
+        return new MethodInfo(lastMethod.stringValue(),
+                              (int) lastType.longValue(),
+                              (int) lastSize.longValue());
+    }
+
+    public MethodInfo getFailedCompile() {
+        return new MethodInfo(lastFailedMethod.stringValue(),
+                              (int) lastFailedType.longValue(),
+                              -1);
+    }
+
+    public MethodInfo getInvalidatedCompile() {
+        return new MethodInfo(lastInvalidatedMethod.stringValue(),
+                              (int) lastInvalidatedType.longValue(),
+                              -1);
+    }
+
+    public java.util.List<Counter> getInternalCompilerCounters() {
+        return jvm.getInternalCounters(CI_COUNTER_NAME_PATTERN);
+    }
+}