rev 6864 : 8061651: Interface to the Lookup Index Cache to improve URLClassPath search time
Summary: Implemented the interface in sun.misc.URLClassPath and corresponding JVM_XXX APIs
Reviewed-by: mchung, acorn, jiangli, dholmes

          --- old/test/testlibrary/whitebox/sun/hotspot/WhiteBox.java
          +++ new/test/testlibrary/whitebox/sun/hotspot/WhiteBox.java

   1    1  /*
   2    2   * Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
   3    3   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4    4   *
   5    5   * This code is free software; you can redistribute it and/or modify it
   6    6   * under the terms of the GNU General Public License version 2 only, as
   7    7   * published by the Free Software Foundation.
   8    8   *
   9    9   * This code is distributed in the hope that it will be useful, but WITHOUT
  10   10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11   11   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12   12   * version 2 for more details (a copy is included in the LICENSE file that
  13   13   * accompanied this code).
  14   14   *
  15   15   * You should have received a copy of the GNU General Public License version
  16   16   * 2 along with this work; if not, write to the Free Software Foundation,
  17   17   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18   18   *
  19   19   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20   20   * or visit www.oracle.com if you need additional information or have any
  21   21   * questions.
  22   22   *

  23   23   */
  24   24  
  25   25  package sun.hotspot;
  26   26  
  27   27  import java.lang.reflect.Executable;
  28   28  import java.util.Arrays;
  29   29  import java.util.List;
  30   30  import java.util.function.Function;
  31   31  import java.util.stream.Stream;
  32   32  import java.security.BasicPermission;
       33 +import java.net.URL;
  33   34  
  34   35  import sun.hotspot.parser.DiagnosticCommand;
  35   36  
  36   37  public class WhiteBox {
  37   38  
  38   39    @SuppressWarnings("serial")
  39   40    public static class WhiteBoxPermission extends BasicPermission {
  40   41      public WhiteBoxPermission(String s) {
  41   42        super(s);
  42   43      }

  43   44    }
  44   45  
  45   46    private WhiteBox() {}
  46   47    private static final WhiteBox instance = new WhiteBox();
  47   48    private static native void registerNatives();
  48   49  
  49   50    /**
  50   51     * Returns the singleton WhiteBox instance.
  51   52     *
  52   53     * The returned WhiteBox object should be carefully guarded
  53   54     * by the caller, since it can be used to read and write data
  54   55     * at arbitrary memory addresses. It must never be passed to
  55   56     * untrusted code.
  56   57     */
  57   58    public synchronized static WhiteBox getWhiteBox() {
  58   59      SecurityManager sm = System.getSecurityManager();
  59   60      if (sm != null) {
  60   61        sm.checkPermission(new WhiteBoxPermission("getInstance"));
  61   62      }
  62   63      return instance;
  63   64    }
  64   65  
  65   66    static {
  66   67      registerNatives();
  67   68    }
  68   69  
  69   70    // Get the maximum heap size supporting COOPs
  70   71    public native long getCompressedOopsMaxHeapSize();
  71   72    // Arguments
  72   73    public native void printHeapSizes();
  73   74  
  74   75    // Memory
  75   76    public native long getObjectAddress(Object o);
  76   77    public native int  getHeapOopSize();

  77   78    public native boolean isObjectInOldGen(Object o);
  78   79    public native long getObjectSize(Object o);
  79   80  
  80   81    // Runtime
  81   82    // Make sure class name is in the correct format
  82   83    public boolean isClassAlive(String name) {
  83   84      return isClassAlive0(name.replace('.', '/'));
  84   85    }
  85   86    private native boolean isClassAlive0(String name);
  86   87  
       88 +  // Resource/Class Lookup Cache
       89 +  public native boolean classKnownToNotExist(ClassLoader loader, String name);
       90 +  public native URL[] getLookupCacheURLs(ClassLoader loader);
       91 +  public native int[] getLookupCacheMatches(ClassLoader loader, String name);
       92 +
  87   93    // G1
  88   94    public native boolean g1InConcurrentMark();
  89   95    public native boolean g1IsHumongous(Object o);
  90   96    public native long    g1NumFreeRegions();
  91   97    public native int     g1RegionSize();
  92   98    public native Object[]    parseCommandLine(String commandline, DiagnosticCommand[] args);
  93   99  
  94  100    // NMT
  95  101    public native long NMTMalloc(long size);
  96  102    public native void NMTFree(long mem);

  97  103    public native long NMTReserveMemory(long size);
  98  104    public native void NMTCommitMemory(long addr, long size);
  99  105    public native void NMTUncommitMemory(long addr, long size);
 100  106    public native void NMTReleaseMemory(long addr, long size);
 101  107    public native void NMTOverflowHashBucket(long num);
 102  108    public native long NMTMallocWithPseudoStack(long size, int index);
 103  109    public native boolean NMTIsDetailSupported();
 104  110    public native boolean NMTChangeTrackingLevel();
 105  111  
 106  112    // Compiler
 107  113    public native void    deoptimizeAll();
 108  114    public        boolean isMethodCompiled(Executable method) {
 109  115      return isMethodCompiled(method, false /*not osr*/);
 110  116    }
 111  117    public native boolean isMethodCompiled(Executable method, boolean isOsr);
 112  118    public        boolean isMethodCompilable(Executable method) {
 113  119      return isMethodCompilable(method, -1 /*any*/);
 114  120    }
 115  121    public        boolean isMethodCompilable(Executable method, int compLevel) {
 116  122      return isMethodCompilable(method, compLevel, false /*not osr*/);
 117  123    }
 118  124    public native boolean isMethodCompilable(Executable method, int compLevel, boolean isOsr);
 119  125    public native boolean isMethodQueuedForCompilation(Executable method);
 120  126    public        int     deoptimizeMethod(Executable method) {
 121  127      return deoptimizeMethod(method, false /*not osr*/);
 122  128    }
 123  129    public native int     deoptimizeMethod(Executable method, boolean isOsr);
 124  130    public        void    makeMethodNotCompilable(Executable method) {
 125  131      makeMethodNotCompilable(method, -1 /*any*/);
 126  132    }
 127  133    public        void    makeMethodNotCompilable(Executable method, int compLevel) {
 128  134      makeMethodNotCompilable(method, compLevel, false /*not osr*/);
 129  135    }
 130  136    public native void    makeMethodNotCompilable(Executable method, int compLevel, boolean isOsr);
 131  137    public        int     getMethodCompilationLevel(Executable method) {
 132  138      return getMethodCompilationLevel(method, false /*not ost*/);
 133  139    }
 134  140    public native int     getMethodCompilationLevel(Executable method, boolean isOsr);
 135  141    public native boolean testSetDontInlineMethod(Executable method, boolean value);
 136  142    public        int     getCompileQueuesSize() {
 137  143      return getCompileQueueSize(-1 /*any*/);
 138  144    }
 139  145    public native int     getCompileQueueSize(int compLevel);
 140  146    public native boolean testSetForceInlineMethod(Executable method, boolean value);
 141  147    public        boolean enqueueMethodForCompilation(Executable method, int compLevel) {
 142  148      return enqueueMethodForCompilation(method, compLevel, -1 /*InvocationEntryBci*/);
 143  149    }
 144  150    public native boolean enqueueMethodForCompilation(Executable method, int compLevel, int entry_bci);
 145  151    public native void    clearMethodState(Executable method);
 146  152    public native int     getMethodEntryBci(Executable method);
 147  153    public native Object[] getNMethod(Executable method, boolean isOsr);
 148  154  
 149  155    // Intered strings
 150  156    public native boolean isInStringTable(String str);
 151  157  
 152  158    // Memory
 153  159    public native void readReservedMemory();
 154  160    public native long allocateMetaspace(ClassLoader classLoader, long size);
 155  161    public native void freeMetaspace(ClassLoader classLoader, long addr, long size);
 156  162    public native long incMetaspaceCapacityUntilGC(long increment);
 157  163    public native long metaspaceCapacityUntilGC();
 158  164  
 159  165    // force Young GC
 160  166    public native void youngGC();
 161  167  
 162  168    // force Full GC
 163  169    public native void fullGC();
 164  170  
 165  171    // Tests on ReservedSpace/VirtualSpace classes
 166  172    public native int stressVirtualSpaceResize(long reservedSpaceSize, long magnitude, long iterations);
 167  173    public native void runMemoryUnitTests();
 168  174    public native void readFromNoaccessArea();
 169  175    public native long getThreadStackSize();
 170  176    public native long getThreadRemainingStackSize();
 171  177  
 172  178    // CPU features
 173  179    public native String getCPUFeatures();
 174  180  
 175  181    // Native extensions
 176  182    public native long getHeapUsageForContext(int context);
 177  183    public native long getHeapRegionCountForContext(int context);
 178  184    public native int getContextForObject(Object obj);
 179  185    public native void printRegionInfo(int context);
 180  186  
 181  187    // VM flags
 182  188    public native void    setBooleanVMFlag(String name, boolean value);
 183  189    public native void    setIntxVMFlag(String name, long value);
 184  190    public native void    setUintxVMFlag(String name, long value);
 185  191    public native void    setUint64VMFlag(String name, long value);
 186  192    public native void    setStringVMFlag(String name, String value);
 187  193    public native void    setDoubleVMFlag(String name, double value);
 188  194    public native Boolean getBooleanVMFlag(String name);
 189  195    public native Long    getIntxVMFlag(String name);
 190  196    public native Long    getUintxVMFlag(String name);
 191  197    public native Long    getUint64VMFlag(String name);
 192  198    public native String  getStringVMFlag(String name);
 193  199    public native Double  getDoubleVMFlag(String name);
 194  200    private final List<Function<String,Object>> flagsGetters = Arrays.asList(
 195  201      this::getBooleanVMFlag, this::getIntxVMFlag, this::getUintxVMFlag,
 196  202      this::getUint64VMFlag, this::getStringVMFlag, this::getDoubleVMFlag);
 197  203  
 198  204    public Object getVMFlag(String name) {
 199  205      return flagsGetters.stream()
 200  206                         .map(f -> f.apply(name))
 201  207                         .filter(x -> x != null)
 202  208                         .findAny()
 203  209                         .orElse(null);
 204  210    }
 205  211  }

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX