1 /*

     2  * Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package sun.management;

    27 

    28 import java.util.regex.*;

    29 import java.util.List;

    30 import java.util.ListIterator;

    31 import java.util.Iterator;

    32 import java.util.ArrayList;

    33 import java.util.Map;

    34 import java.util.TreeMap;

    35 import sun.management.counter.*;

    36 

    37 /**

    38  * Implementation class of HotspotCompilationMBean interface.

    39  *

    40  * Internal, uncommitted management interface for Hotspot compilation

    41  * system.

    42  *

    43  */

    44 class HotspotCompilation

    45     implements HotspotCompilationMBean {

    46 

    47     private VMManagement jvm;

    48 

    49     /**

    50      * Constructor of HotspotRuntime class.

    51      */

    52     HotspotCompilation(VMManagement vm) {

    53         jvm = vm;

    54         initCompilerCounters();

    55     }

    56 

    57     // Performance counter support

    58     private static final String JAVA_CI    = "java.ci.";

    59     private static final String COM_SUN_CI = "com.sun.ci.";

    60     private static final String SUN_CI     = "sun.ci.";

    61     private static final String CI_COUNTER_NAME_PATTERN =

    62         JAVA_CI + "|" + COM_SUN_CI + "|" + SUN_CI;

    63 

    64     private LongCounter compilerThreads;

    65     private LongCounter totalCompiles;

    66     private LongCounter totalBailouts;

    67     private LongCounter totalInvalidates;

    68     private LongCounter nmethodCodeSize;

    69     private LongCounter nmethodSize;

    70     private StringCounter lastMethod;

    71     private LongCounter lastSize;

    72     private LongCounter lastType;

    73     private StringCounter lastFailedMethod;

    74     private LongCounter lastFailedType;

    75     private StringCounter lastInvalidatedMethod;

    76     private LongCounter lastInvalidatedType;

    77 

    78     private class CompilerThreadInfo {

    79         String name;

    80         StringCounter method;

    81         LongCounter type;

    82         LongCounter compiles;

    83         LongCounter time;

    84         CompilerThreadInfo(String bname, int index) {

    85             String basename = bname + "." + index + ".";

    86             this.name = bname + "-" + index;

    87             this.method = (StringCounter) lookup(basename + "method");

    88             this.type = (LongCounter) lookup(basename + "type");

    89             this.compiles = (LongCounter) lookup(basename + "compiles");

    90             this.time = (LongCounter) lookup(basename + "time");

    91         }

    92 

    93         @SuppressWarnings("deprecation")

    94         CompilerThreadStat getCompilerThreadStat() {

    95             MethodInfo minfo = new MethodInfo(method.stringValue(),

    96                                               (int) type.longValue(),

    97                                               -1);

    98             return new CompilerThreadStat(name,

    99                                           compiles.longValue(),

   100                                           time.longValue(),

   101                                           minfo);

   102         }

   103     }

   104     private List<CompilerThreadInfo> threads;

   105     private int numActiveThreads; // number of active compiler threads

   106 

   107     private Map<String, Counter> counters;

   108     private Counter lookup(String name) {

   109         Counter c = null;

   110 

   111         // Only one counter exists with the specified name in the

   112         // current implementation.  We first look up in the SUN_CI namespace

   113         // since most counters are in SUN_CI namespace.

   114 

   115         if ((c = counters.get(SUN_CI + name)) != null) {

   116             return c;

   117         }

   118         if ((c = counters.get(COM_SUN_CI + name)) != null) {

   119             return c;

   120         }

   121         if ((c = counters.get(JAVA_CI + name)) != null) {

   122             return c;

   123         }

   124 

   125         // FIXME: should tolerate if counter doesn't exist

   126         throw new AssertionError("Counter " + name + " does not exist");

   127     }

   128 

   129     private void initCompilerCounters() {

   130         // Build a tree map of the current list of performance counters

   131         counters = new TreeMap<>();

   132         for (Counter c: getInternalCompilerCounters()) {

   133             counters.put(c.getName(), c);

   134         }

   135 

   136         compilerThreads = (LongCounter) lookup("threads");

   137         totalCompiles = (LongCounter) lookup("totalCompiles");

   138         totalBailouts = (LongCounter) lookup("totalBailouts");

   139         totalInvalidates = (LongCounter) lookup("totalInvalidates");

   140         nmethodCodeSize = (LongCounter) lookup("nmethodCodeSize");

   141         nmethodSize = (LongCounter) lookup("nmethodSize");

   142         lastMethod = (StringCounter) lookup("lastMethod");

   143         lastSize = (LongCounter) lookup("lastSize");

   144         lastType = (LongCounter) lookup("lastType");

   145         lastFailedMethod = (StringCounter) lookup("lastFailedMethod");

   146         lastFailedType = (LongCounter) lookup("lastFailedType");

   147         lastInvalidatedMethod = (StringCounter) lookup("lastInvalidatedMethod");

   148         lastInvalidatedType = (LongCounter) lookup("lastInvalidatedType");

   149 

   150         numActiveThreads = (int) compilerThreads.longValue();

   151 

   152         // Allocate CompilerThreadInfo for compilerThread and adaptorThread

   153         threads = new ArrayList<CompilerThreadInfo>();

   154 

   155         for (int i = 0; i < numActiveThreads; i++) {

   156             if (counters.containsKey(SUN_CI + "compilerThread." + i + ".method")) {

   157                 threads.add(new CompilerThreadInfo("compilerThread", i));

   158             }

   159         }

   160     }

   161 

   162     public int getCompilerThreadCount() {

   163         return numActiveThreads;

   164     }

   165 

   166     public long getTotalCompileCount() {

   167         return totalCompiles.longValue();

   168     }

   169 

   170     public long getBailoutCompileCount() {

   171         return totalBailouts.longValue();

   172     }

   173 

   174     public long getInvalidatedCompileCount() {

   175         return totalInvalidates.longValue();

   176     }

   177 

   178     public long getCompiledMethodCodeSize() {

   179         return nmethodCodeSize.longValue();

   180     }

   181 

   182     public long getCompiledMethodSize() {

   183         return nmethodSize.longValue();

   184     }

   185 

   186     @Deprecated

   187     public List<CompilerThreadStat> getCompilerThreadStats() {

   188         List<CompilerThreadStat> list = new ArrayList<>(threads.size());

   189         for (CompilerThreadInfo info : threads) {

   190             list.add(info.getCompilerThreadStat());

   191         }

   192         return list;

   193     }

   194 

   195     public MethodInfo getLastCompile() {

   196         return new MethodInfo(lastMethod.stringValue(),

   197                               (int) lastType.longValue(),

   198                               (int) lastSize.longValue());

   199     }

   200 

   201     public MethodInfo getFailedCompile() {

   202         return new MethodInfo(lastFailedMethod.stringValue(),

   203                               (int) lastFailedType.longValue(),

   204                               -1);

   205     }

   206 

   207     public MethodInfo getInvalidatedCompile() {

   208         return new MethodInfo(lastInvalidatedMethod.stringValue(),

   209                               (int) lastInvalidatedType.longValue(),

   210                               -1);

   211     }

   212 

   213     public java.util.List<Counter> getInternalCompilerCounters() {

   214         return jvm.getInternalCounters(CI_COUNTER_NAME_PATTERN);

   215     }

   216 }