1 /*
2 * Copyright (c) 1996, 2005, 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.misc;
27
28 import java.util.Properties;
29 import java.util.HashMap;
30 import java.util.Map;
31 import java.util.Set;
32
33 public class VM {
34
35 /* The following methods used to be native methods that instruct
36 * the VM to selectively suspend certain threads in low-memory
37 * situations. They are inherently dangerous and not implementable
38 * on native threads. We removed them in JDK 1.2. The skeletons
39 * remain so that existing applications that use these methods
40 * will still work.
41 */
42 private static boolean suspended = false;
43
44 /** @deprecated */
45 @Deprecated
46 public static boolean threadsSuspended() {
47 return suspended;
48 }
49
50 public static boolean allowThreadSuspension(ThreadGroup g, boolean b) {
51 return g.allowThreadSuspension(b);
52 }
53
54 /** @deprecated */
55 @Deprecated
56 public static boolean suspendThreads() {
57 suspended = true;
58 return true;
59 }
60
61 // Causes any suspended threadgroups to be resumed.
62 /** @deprecated */
63 @Deprecated
64 public static void unsuspendThreads() {
65 suspended = false;
66 }
67
68 // Causes threadgroups no longer marked suspendable to be resumed.
69 /** @deprecated */
70 @Deprecated
71 public static void unsuspendSomeThreads() {
72 }
73
74 /* Deprecated fields and methods -- Memory advice not supported in 1.2 */
75
76 /** @deprecated */
77 @Deprecated
78 public static final int STATE_GREEN = 1;
79
80 /** @deprecated */
81 @Deprecated
82 public static final int STATE_YELLOW = 2;
83
84 /** @deprecated */
85 @Deprecated
86 public static final int STATE_RED = 3;
87
88 /** @deprecated */
89 @Deprecated
90 public static final int getState() {
91 return STATE_GREEN;
92 }
93
94 /** @deprecated */
95 @Deprecated
96 public static void registerVMNotification(VMNotification n) { }
97
98 /** @deprecated */
99 @Deprecated
100 public static void asChange(int as_old, int as_new) { }
101
102 /** @deprecated */
103 @Deprecated
104 public static void asChange_otherthread(int as_old, int as_new) { }
105
106 /*
107 * Not supported in 1.2 because these will have to be exported as
108 * JVM functions, and we are not sure we want do that. Leaving
109 * here so it can be easily resurrected -- just remove the //
110 * comments.
111 */
112
113 /**
114 * Resume Java profiling. All profiling data is added to any
115 * earlier profiling, unless <code>resetJavaProfiler</code> is
116 * called in between. If profiling was not started from the
117 * command line, <code>resumeJavaProfiler</code> will start it.
118 * <p>
119 *
120 * NOTE: Profiling must be enabled from the command line for a
121 * java.prof report to be automatically generated on exit; if not,
122 * writeJavaProfilerReport must be invoked to write a report.
123 *
124 * @see resetJavaProfiler
125 * @see writeJavaProfilerReport
126 */
127
128 // public native static void resumeJavaProfiler();
129
130 /**
131 * Suspend Java profiling.
132 */
133 // public native static void suspendJavaProfiler();
134
135 /**
136 * Initialize Java profiling. Any accumulated profiling
137 * information is discarded.
138 */
139 // public native static void resetJavaProfiler();
140
141 /**
142 * Write the current profiling contents to the file "java.prof".
143 * If the file already exists, it will be overwritten.
144 */
145 // public native static void writeJavaProfilerReport();
146
147
148 private static volatile boolean booted = false;
149
150 // Invoked by by System.initializeSystemClass just before returning.
151 // Subsystems that are invoked during initialization can check this
152 // property in order to avoid doing things that should wait until the
153 // application class loader has been set up.
154 //
155 public static void booted() {
156 booted = true;
157 }
158
159 public static boolean isBooted() {
160 return booted;
161 }
162
163 // A user-settable upper limit on the maximum amount of allocatable direct
164 // buffer memory. This value may be changed during VM initialization if
165 // "java" is launched with "-XX:MaxDirectMemorySize=<size>".
166 //
167 // The initial value of this field is arbitrary; during JRE initialization
168 // it will be reset to the value specified on the command line, if any,
169 // otherwise to Runtime.getRuntime.maxDirectMemory().
170 //
171 private static long directMemory = 64 * 1024 * 1024;
172
173 // Returns the maximum amount of allocatable direct buffer memory.
174 // The directMemory variable is initialized during system initialization
175 // in the saveAndRemoveProperties method.
176 //
177 public static long maxDirectMemory() {
178 return directMemory;
179 }
180
181 // User-controllable flag that determines if direct buffers should be page
182 // aligned. The "-XX:+PageAlignDirectMemory" option can be used to force
183 // buffers, allocated by ByteBuffer.allocateDirect, to be page aligned.
184 private static boolean pageAlignDirectMemory;
185
186 // Returns {@code true} if the direct buffers should be page aligned. This
187 // variable is initialized by saveAndRemoveProperties.
188 public static boolean isDirectMemoryPageAligned() {
189 return pageAlignDirectMemory;
190 }
191
192 // A user-settable boolean to determine whether ClassLoader.loadClass should
193 // accept array syntax. This value may be changed during VM initialization
194 // via the system property "sun.lang.ClassLoader.allowArraySyntax".
195 //
196 // The default for 1.5 is "true", array syntax is allowed. In 1.6, the
197 // default will be "false". The presence of this system property to
198 // control array syntax allows applications the ability to preview this new
199 // behaviour.
200 //
201 private static boolean defaultAllowArraySyntax = false;
202 private static boolean allowArraySyntax = defaultAllowArraySyntax;
203
204 // The allowArraySyntax boolean is initialized during system initialization
205 // in the saveAndRemoveProperties method.
206 //
207 // It is initialized based on the value of the system property
208 // "sun.lang.ClassLoader.allowArraySyntax". If the system property is not
209 // provided, the default for 1.5 is "true". In 1.6, the default will be
210 // "false". If the system property is provided, then the value of
211 // allowArraySyntax will be equal to "true" if Boolean.parseBoolean()
212 // returns "true". Otherwise, the field will be set to "false".
213 //
214 public static boolean allowArraySyntax() {
215 return allowArraySyntax;
216 }
217
218 /**
219 * Returns the system property of the specified key saved at
220 * system initialization time. This method should only be used
221 * for the system properties that are not changed during runtime.
222 * It accesses a private copy of the system properties so
223 * that user's locking of the system properties object will not
224 * cause the library to deadlock.
225 *
226 * Note that the saved system properties do not include
227 * the ones set by sun.misc.Version.init().
228 *
229 */
230 public static String getSavedProperty(String key) {
231 if (savedProps.isEmpty())
232 throw new IllegalStateException("Should be non-empty if initialized");
233
234 return savedProps.getProperty(key);
235 }
236
237 private static final Properties savedProps = new Properties();
238
239 // Save a private copy of the system properties and remove
240 // the system properties that are not intended for public access.
241 //
242 // This method can only be invoked during system initialization.
243 public static void saveAndRemoveProperties(Properties props) {
244 if (booted)
245 throw new IllegalStateException("System initialization has completed");
246
247 savedProps.putAll(props);
248
249 // Set the maximum amount of direct memory. This value is controlled
250 // by the vm option -XX:MaxDirectMemorySize=<size>.
251 // The maximum amount of allocatable direct buffer memory (in bytes)
252 // from the system property sun.nio.MaxDirectMemorySize set by the VM.
253 // The system property will be removed.
254 String s = (String)props.remove("sun.nio.MaxDirectMemorySize");
255 if (s != null) {
256 if (s.equals("-1")) {
257 // -XX:MaxDirectMemorySize not given, take default
258 directMemory = Runtime.getRuntime().maxMemory();
259 } else {
260 long l = Long.parseLong(s);
261 if (l > -1)
262 directMemory = l;
263 }
264 }
265
266 // Check if direct buffers should be page aligned
267 s = (String)props.remove("sun.nio.PageAlignDirectMemory");
268 if ("true".equals(s))
269 pageAlignDirectMemory = true;
270
271 // Set a boolean to determine whether ClassLoader.loadClass accepts
272 // array syntax. This value is controlled by the system property
273 // "sun.lang.ClassLoader.allowArraySyntax".
274 s = props.getProperty("sun.lang.ClassLoader.allowArraySyntax");
275 allowArraySyntax = (s == null
276 ? defaultAllowArraySyntax
277 : Boolean.parseBoolean(s));
278
279 // Remove other private system properties
280 // used by java.lang.Integer.IntegerCache
281 props.remove("java.lang.Integer.IntegerCache.high");
282
283 // used by java.util.zip.ZipFile
284 props.remove("sun.zip.disableMemoryMapping");
285 }
286
287 // Initialize any miscellenous operating system settings that need to be
288 // set for the class libraries.
289 //
290 public static void initializeOSEnvironment() {
291 if (!booted) {
292 OSEnvironment.initialize();
293 }
294 }
295
296 /* Current count of objects pending for finalization */
297 private static volatile int finalRefCount = 0;
298
299 /* Peak count of objects pending for finalization */
300 private static volatile int peakFinalRefCount = 0;
301
302 /*
303 * Gets the number of objects pending for finalization.
304 *
305 * @return the number of objects pending for finalization.
306 */
307 public static int getFinalRefCount() {
308 return finalRefCount;
309 }
310
311 /*
312 * Gets the peak number of objects pending for finalization.
313 *
314 * @return the peak number of objects pending for finalization.
315 */
316 public static int getPeakFinalRefCount() {
317 return peakFinalRefCount;
318 }
319
320 /*
321 * Add <tt>n</tt> to the objects pending for finalization count.
322 *
323 * @param n an integer value to be added to the objects pending
324 * for finalization count
325 */
326 public static void addFinalRefCount(int n) {
327 // The caller must hold lock to synchronize the update.
328
329 finalRefCount += n;
330 if (finalRefCount > peakFinalRefCount) {
331 peakFinalRefCount = finalRefCount;
332 }
333 }
334
335
336 public static Thread.State toThreadState(int threadStatus) {
337 // Initialize the threadStateMap
338 initThreadStateMap();
339
340 Thread.State s = threadStateMap.get(threadStatus);
341 if (s == null) {
342 // default to RUNNABLE if the threadStatus value is unknown
343 s = Thread.State.RUNNABLE;
344 }
345 return s;
346 }
347
348 // a map of threadStatus values to the corresponding Thread.State
349 private static Map<Integer, Thread.State> threadStateMap = null;
350 private static Map<Integer, String> threadStateNames = null;
351
352 private synchronized static void initThreadStateMap() {
353 if (threadStateMap != null) {
354 return;
355 }
356
357 final Thread.State[] ts = Thread.State.values();
358
359 final int[][] vmThreadStateValues = new int[ts.length][];
360 final String[][] vmThreadStateNames = new String[ts.length][];
361 getThreadStateValues(vmThreadStateValues, vmThreadStateNames);
362
363 threadStateMap = new HashMap<Integer, Thread.State>();
364 threadStateNames = new HashMap<Integer, String>();
365 for (int i = 0; i < ts.length; i++) {
366 String state = ts[i].name();
367 int[] values = null;
368 String[] names = null;
369 for (int j = 0; j < ts.length; j++) {
370 if (vmThreadStateNames[j][0].startsWith(state)) {
371 values = vmThreadStateValues[j];
372 names = vmThreadStateNames[j];
373 }
374 }
375 if (values == null) {
376 throw new InternalError("No VM thread state mapped to " +
377 state);
378 }
379 if (values.length != names.length) {
380 throw new InternalError("VM thread state values and names " +
381 " mapped to " + state + ": length not matched" );
382 }
383 for (int k = 0; k < values.length; k++) {
384 threadStateMap.put(values[k], ts[i]);
385 threadStateNames.put(values[k], names[k]);
386 }
387 }
388 }
389 // Fill in vmThreadStateValues with int arrays, each of which contains
390 // the threadStatus values mapping to the Thread.State enum constant.
391 // Fill in vmThreadStateNames with String arrays, each of which contains
392 // the name of each threadStatus value of the format:
393 // <Thread.State.name()>[.<Substate name>]
394 // e.g. WAITING.OBJECT_WAIT
395 //
396 private native static void getThreadStateValues(int[][] vmThreadStateValues,
397 String[][] vmThreadStateNames);
398
399 static {
400 initialize();
401 }
402 private native static void initialize();
403 }