Print this page
rev 6891 : 8062247: [TESTBUG] Allow WhiteBox test to access JVM offsets
Reviewed-by: coleenp, iklam, mseledtsov
Contributed-by: yumin.qi@oracle.com
| Split |
Split |
Close |
| Expand all |
| Collapse all |
--- old/hotspot/test/testlibrary/whitebox/sun/hotspot/WhiteBox.java
+++ new/hotspot/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 33 import java.net.URL;
34 34
35 35 import sun.hotspot.parser.DiagnosticCommand;
36 36
37 37 public class WhiteBox {
38 38
39 39 @SuppressWarnings("serial")
40 40 public static class WhiteBoxPermission extends BasicPermission {
41 41 public WhiteBoxPermission(String s) {
42 42 super(s);
43 43 }
44 44 }
45 45
46 46 private WhiteBox() {}
47 47 private static final WhiteBox instance = new WhiteBox();
48 48 private static native void registerNatives();
49 49
50 50 /**
51 51 * Returns the singleton WhiteBox instance.
52 52 *
53 53 * The returned WhiteBox object should be carefully guarded
54 54 * by the caller, since it can be used to read and write data
55 55 * at arbitrary memory addresses. It must never be passed to
56 56 * untrusted code.
57 57 */
58 58 public synchronized static WhiteBox getWhiteBox() {
59 59 SecurityManager sm = System.getSecurityManager();
60 60 if (sm != null) {
61 61 sm.checkPermission(new WhiteBoxPermission("getInstance"));
62 62 }
63 63 return instance;
64 64 }
65 65
66 66 static {
67 67 registerNatives();
68 68 }
69 69
70 70 // Get the maximum heap size supporting COOPs
71 71 public native long getCompressedOopsMaxHeapSize();
72 72 // Arguments
73 73 public native void printHeapSizes();
74 74
75 75 // Memory
76 76 public native long getObjectAddress(Object o);
77 77 public native int getHeapOopSize();
78 78 public native boolean isObjectInOldGen(Object o);
79 79 public native long getObjectSize(Object o);
80 80
81 81 // Runtime
82 82 // Make sure class name is in the correct format
83 83 public boolean isClassAlive(String name) {
84 84 return isClassAlive0(name.replace('.', '/'));
85 85 }
86 86 private native boolean isClassAlive0(String name);
87 87
88 88 // Resource/Class Lookup Cache
89 89 public native boolean classKnownToNotExist(ClassLoader loader, String name);
90 90 public native URL[] getLookupCacheURLs(ClassLoader loader);
91 91 public native int[] getLookupCacheMatches(ClassLoader loader, String name);
92 92
93 93 // G1
94 94 public native boolean g1InConcurrentMark();
95 95 public native boolean g1IsHumongous(Object o);
96 96 public native long g1NumFreeRegions();
|
↓ open down ↓ |
96 lines elided |
↑ open up ↑ |
97 97 public native int g1RegionSize();
98 98 public native Object[] parseCommandLine(String commandline, DiagnosticCommand[] args);
99 99
100 100 // NMT
101 101 public native long NMTMalloc(long size);
102 102 public native void NMTFree(long mem);
103 103 public native long NMTReserveMemory(long size);
104 104 public native void NMTCommitMemory(long addr, long size);
105 105 public native void NMTUncommitMemory(long addr, long size);
106 106 public native void NMTReleaseMemory(long addr, long size);
107 - public native void NMTOverflowHashBucket(long num);
108 107 public native long NMTMallocWithPseudoStack(long size, int index);
109 108 public native boolean NMTIsDetailSupported();
110 109 public native boolean NMTChangeTrackingLevel();
110 + public native int NMTGetHashSize();
111 111
112 112 // Compiler
113 113 public native void deoptimizeAll();
114 114 public boolean isMethodCompiled(Executable method) {
115 115 return isMethodCompiled(method, false /*not osr*/);
116 116 }
117 117 public native boolean isMethodCompiled(Executable method, boolean isOsr);
118 118 public boolean isMethodCompilable(Executable method) {
119 119 return isMethodCompilable(method, -1 /*any*/);
120 120 }
121 121 public boolean isMethodCompilable(Executable method, int compLevel) {
122 122 return isMethodCompilable(method, compLevel, false /*not osr*/);
123 123 }
124 124 public native boolean isMethodCompilable(Executable method, int compLevel, boolean isOsr);
125 125 public native boolean isMethodQueuedForCompilation(Executable method);
126 126 public int deoptimizeMethod(Executable method) {
127 127 return deoptimizeMethod(method, false /*not osr*/);
128 128 }
129 129 public native int deoptimizeMethod(Executable method, boolean isOsr);
130 130 public void makeMethodNotCompilable(Executable method) {
131 131 makeMethodNotCompilable(method, -1 /*any*/);
132 132 }
133 133 public void makeMethodNotCompilable(Executable method, int compLevel) {
134 134 makeMethodNotCompilable(method, compLevel, false /*not osr*/);
135 135 }
136 136 public native void makeMethodNotCompilable(Executable method, int compLevel, boolean isOsr);
137 137 public int getMethodCompilationLevel(Executable method) {
138 138 return getMethodCompilationLevel(method, false /*not ost*/);
139 139 }
140 140 public native int getMethodCompilationLevel(Executable method, boolean isOsr);
141 141 public native boolean testSetDontInlineMethod(Executable method, boolean value);
142 142 public int getCompileQueuesSize() {
143 143 return getCompileQueueSize(-1 /*any*/);
144 144 }
145 145 public native int getCompileQueueSize(int compLevel);
146 146 public native boolean testSetForceInlineMethod(Executable method, boolean value);
147 147 public boolean enqueueMethodForCompilation(Executable method, int compLevel) {
148 148 return enqueueMethodForCompilation(method, compLevel, -1 /*InvocationEntryBci*/);
149 149 }
150 150 public native boolean enqueueMethodForCompilation(Executable method, int compLevel, int entry_bci);
151 151 public native void clearMethodState(Executable method);
152 152 public native int getMethodEntryBci(Executable method);
153 153 public native Object[] getNMethod(Executable method, boolean isOsr);
154 154
155 155 // Intered strings
156 156 public native boolean isInStringTable(String str);
157 157
158 158 // Memory
159 159 public native void readReservedMemory();
160 160 public native long allocateMetaspace(ClassLoader classLoader, long size);
161 161 public native void freeMetaspace(ClassLoader classLoader, long addr, long size);
162 162 public native long incMetaspaceCapacityUntilGC(long increment);
163 163 public native long metaspaceCapacityUntilGC();
164 164
165 165 // force Young GC
166 166 public native void youngGC();
167 167
168 168 // force Full GC
169 169 public native void fullGC();
170 170
171 171 // Tests on ReservedSpace/VirtualSpace classes
172 172 public native int stressVirtualSpaceResize(long reservedSpaceSize, long magnitude, long iterations);
173 173 public native void runMemoryUnitTests();
174 174 public native void readFromNoaccessArea();
175 175 public native long getThreadStackSize();
176 176 public native long getThreadRemainingStackSize();
177 177
178 178 // CPU features
179 179 public native String getCPUFeatures();
180 180
181 181 // Native extensions
182 182 public native long getHeapUsageForContext(int context);
183 183 public native long getHeapRegionCountForContext(int context);
184 184 public native int getContextForObject(Object obj);
185 185 public native void printRegionInfo(int context);
186 186
187 187 // VM flags
188 188 public native void setBooleanVMFlag(String name, boolean value);
189 189 public native void setIntxVMFlag(String name, long value);
190 190 public native void setUintxVMFlag(String name, long value);
191 191 public native void setUint64VMFlag(String name, long value);
192 192 public native void setStringVMFlag(String name, String value);
193 193 public native void setDoubleVMFlag(String name, double value);
194 194 public native Boolean getBooleanVMFlag(String name);
195 195 public native Long getIntxVMFlag(String name);
196 196 public native Long getUintxVMFlag(String name);
197 197 public native Long getUint64VMFlag(String name);
198 198 public native String getStringVMFlag(String name);
199 199 public native Double getDoubleVMFlag(String name);
200 200 private final List<Function<String,Object>> flagsGetters = Arrays.asList(
|
↓ open down ↓ |
80 lines elided |
↑ open up ↑ |
201 201 this::getBooleanVMFlag, this::getIntxVMFlag, this::getUintxVMFlag,
202 202 this::getUint64VMFlag, this::getStringVMFlag, this::getDoubleVMFlag);
203 203
204 204 public Object getVMFlag(String name) {
205 205 return flagsGetters.stream()
206 206 .map(f -> f.apply(name))
207 207 .filter(x -> x != null)
208 208 .findAny()
209 209 .orElse(null);
210 210 }
211 + public native int getOffsetForName0(String name);
212 + public int getOffsetForName(String name) throws Exception {
213 + int offset = getOffsetForName0(name);
214 + if (offset == -1) {
215 + throw new RuntimeException(name + " not found");
216 + }
217 + return offset;
218 + }
219 +
211 220 }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX