369 lines
13 KiB
Java
369 lines
13 KiB
Java
/*
|
|
* Copyright (c) 1996, 2011, 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.misc;
|
|
|
|
import static java.lang.Thread.State.*;
|
|
import java.util.Properties;
|
|
import java.util.HashMap;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
|
|
public class VM {
|
|
|
|
/* The following methods used to be native methods that instruct
|
|
* the VM to selectively suspend certain threads in low-memory
|
|
* situations. They are inherently dangerous and not implementable
|
|
* on native threads. We removed them in JDK 1.2. The skeletons
|
|
* remain so that existing applications that use these methods
|
|
* will still work.
|
|
*/
|
|
private static boolean suspended = false;
|
|
|
|
/** @deprecated */
|
|
@Deprecated
|
|
public static boolean threadsSuspended() {
|
|
return suspended;
|
|
}
|
|
|
|
public static boolean allowThreadSuspension(ThreadGroup g, boolean b) {
|
|
return g.allowThreadSuspension(b);
|
|
}
|
|
|
|
/** @deprecated */
|
|
@Deprecated
|
|
public static boolean suspendThreads() {
|
|
suspended = true;
|
|
return true;
|
|
}
|
|
|
|
// Causes any suspended threadgroups to be resumed.
|
|
/** @deprecated */
|
|
@Deprecated
|
|
public static void unsuspendThreads() {
|
|
suspended = false;
|
|
}
|
|
|
|
// Causes threadgroups no longer marked suspendable to be resumed.
|
|
/** @deprecated */
|
|
@Deprecated
|
|
public static void unsuspendSomeThreads() {
|
|
}
|
|
|
|
/* Deprecated fields and methods -- Memory advice not supported in 1.2 */
|
|
|
|
/** @deprecated */
|
|
@Deprecated
|
|
public static final int STATE_GREEN = 1;
|
|
|
|
/** @deprecated */
|
|
@Deprecated
|
|
public static final int STATE_YELLOW = 2;
|
|
|
|
/** @deprecated */
|
|
@Deprecated
|
|
public static final int STATE_RED = 3;
|
|
|
|
/** @deprecated */
|
|
@Deprecated
|
|
public static final int getState() {
|
|
return STATE_GREEN;
|
|
}
|
|
|
|
/** @deprecated */
|
|
@Deprecated
|
|
public static void registerVMNotification(VMNotification n) { }
|
|
|
|
/** @deprecated */
|
|
@Deprecated
|
|
public static void asChange(int as_old, int as_new) { }
|
|
|
|
/** @deprecated */
|
|
@Deprecated
|
|
public static void asChange_otherthread(int as_old, int as_new) { }
|
|
|
|
/*
|
|
* Not supported in 1.2 because these will have to be exported as
|
|
* JVM functions, and we are not sure we want do that. Leaving
|
|
* here so it can be easily resurrected -- just remove the //
|
|
* comments.
|
|
*/
|
|
|
|
/**
|
|
* Resume Java profiling. All profiling data is added to any
|
|
* earlier profiling, unless <code>resetJavaProfiler</code> is
|
|
* called in between. If profiling was not started from the
|
|
* command line, <code>resumeJavaProfiler</code> will start it.
|
|
* <p>
|
|
*
|
|
* NOTE: Profiling must be enabled from the command line for a
|
|
* java.prof report to be automatically generated on exit; if not,
|
|
* writeJavaProfilerReport must be invoked to write a report.
|
|
*
|
|
* @see resetJavaProfiler
|
|
* @see writeJavaProfilerReport
|
|
*/
|
|
|
|
// public native static void resumeJavaProfiler();
|
|
|
|
/**
|
|
* Suspend Java profiling.
|
|
*/
|
|
// public native static void suspendJavaProfiler();
|
|
|
|
/**
|
|
* Initialize Java profiling. Any accumulated profiling
|
|
* information is discarded.
|
|
*/
|
|
// public native static void resetJavaProfiler();
|
|
|
|
/**
|
|
* Write the current profiling contents to the file "java.prof".
|
|
* If the file already exists, it will be overwritten.
|
|
*/
|
|
// public native static void writeJavaProfilerReport();
|
|
|
|
private static volatile boolean booted = false;
|
|
|
|
static {
|
|
// [IKVM] force System properties initialization ("booting")
|
|
System.lineSeparator();
|
|
}
|
|
|
|
// Invoked by by System.initializeSystemClass just before returning.
|
|
// Subsystems that are invoked during initialization can check this
|
|
// property in order to avoid doing things that should wait until the
|
|
// application class loader has been set up.
|
|
//
|
|
// [IKVM] The above isn't applicable. We only use the booted flag
|
|
// for the system properties (this is required because the system properties
|
|
// use java.util.Hashtable (via java.util.Properties) and it relies on
|
|
// the booted flag to determine whether it is safe to query the system
|
|
// properties).
|
|
public static void booted() {
|
|
booted = true;
|
|
}
|
|
|
|
public static boolean isBooted() {
|
|
return booted;
|
|
}
|
|
|
|
// Returns the maximum amount of allocatable direct buffer memory.
|
|
// The directMemory variable is initialized during system initialization
|
|
// in the saveAndRemoveProperties method.
|
|
//
|
|
public static long maxDirectMemory() {
|
|
// we don't support -XX:MaxDirectMemorySize
|
|
return Long.MAX_VALUE;
|
|
}
|
|
|
|
// User-controllable flag that determines if direct buffers should be page
|
|
// aligned. The "-XX:+PageAlignDirectMemory" option can be used to force
|
|
// buffers, allocated by ByteBuffer.allocateDirect, to be page aligned.
|
|
private static boolean pageAlignDirectMemory;
|
|
|
|
// Returns {@code true} if the direct buffers should be page aligned. This
|
|
// variable is initialized by saveAndRemoveProperties.
|
|
public static boolean isDirectMemoryPageAligned() {
|
|
return pageAlignDirectMemory;
|
|
}
|
|
|
|
// A user-settable boolean to determine whether ClassLoader.loadClass should
|
|
// accept array syntax. This value may be changed during VM initialization
|
|
// via the system property "sun.lang.ClassLoader.allowArraySyntax".
|
|
//
|
|
// The default for 1.5 is "true", array syntax is allowed. In 1.6, the
|
|
// default will be "false". The presence of this system property to
|
|
// control array syntax allows applications the ability to preview this new
|
|
// behaviour.
|
|
//
|
|
private static boolean defaultAllowArraySyntax = false;
|
|
private static boolean allowArraySyntax = defaultAllowArraySyntax;
|
|
|
|
// The allowArraySyntax boolean is initialized during system initialization
|
|
// in the saveAndRemoveProperties method.
|
|
//
|
|
// It is initialized based on the value of the system property
|
|
// "sun.lang.ClassLoader.allowArraySyntax". If the system property is not
|
|
// provided, the default for 1.5 is "true". In 1.6, the default will be
|
|
// "false". If the system property is provided, then the value of
|
|
// allowArraySyntax will be equal to "true" if Boolean.parseBoolean()
|
|
// returns "true". Otherwise, the field will be set to "false".
|
|
//
|
|
public static boolean allowArraySyntax() {
|
|
return allowArraySyntax;
|
|
}
|
|
|
|
/**
|
|
* Returns the system property of the specified key saved at
|
|
* system initialization time. This method should only be used
|
|
* for the system properties that are not changed during runtime.
|
|
* It accesses a private copy of the system properties so
|
|
* that user's locking of the system properties object will not
|
|
* cause the library to deadlock.
|
|
*
|
|
* Note that the saved system properties do not include
|
|
* the ones set by sun.misc.Version.init().
|
|
*
|
|
*/
|
|
public static String getSavedProperty(String key) {
|
|
if (Lazy.savedProps.isEmpty())
|
|
throw new IllegalStateException("Should be non-empty if initialized");
|
|
|
|
return Lazy.savedProps.getProperty(key);
|
|
}
|
|
|
|
// TODO: the Property Management needs to be refactored and
|
|
// the appropriate prop keys need to be accessible to the
|
|
// calling classes to avoid duplication of keys.
|
|
static final class Lazy {
|
|
static final Properties savedProps = new Properties();
|
|
}
|
|
|
|
// Save a private copy of the system properties and remove
|
|
// the system properties that are not intended for public access.
|
|
//
|
|
// This method can only be invoked during system initialization.
|
|
public static void saveAndRemoveProperties(Properties props) {
|
|
if (booted)
|
|
throw new IllegalStateException("System initialization has completed");
|
|
|
|
Lazy.savedProps.putAll(props);
|
|
|
|
// Set the maximum amount of direct memory. This value is controlled
|
|
// by the vm option -XX:MaxDirectMemorySize=<size>.
|
|
// The maximum amount of allocatable direct buffer memory (in bytes)
|
|
// from the system property sun.nio.MaxDirectMemorySize set by the VM.
|
|
// The system property will be removed.
|
|
String s = (String)props.remove("sun.nio.MaxDirectMemorySize");
|
|
// [IKVM] we don't support the -XX:MaxDirectMemorySize=<size> option.
|
|
|
|
// Check if direct buffers should be page aligned
|
|
s = (String)props.remove("sun.nio.PageAlignDirectMemory");
|
|
if ("true".equals(s))
|
|
pageAlignDirectMemory = true;
|
|
|
|
// Set a boolean to determine whether ClassLoader.loadClass accepts
|
|
// array syntax. This value is controlled by the system property
|
|
// "sun.lang.ClassLoader.allowArraySyntax".
|
|
s = props.getProperty("sun.lang.ClassLoader.allowArraySyntax");
|
|
allowArraySyntax = (s == null
|
|
? defaultAllowArraySyntax
|
|
: Boolean.parseBoolean(s));
|
|
|
|
// Remove other private system properties
|
|
// used by java.lang.Integer.IntegerCache
|
|
props.remove("java.lang.Integer.IntegerCache.high");
|
|
|
|
// used by java.util.zip.ZipFile
|
|
props.remove("sun.zip.disableMemoryMapping");
|
|
|
|
// used by sun.launcher.LauncherHelper
|
|
props.remove("sun.java.launcher.diag");
|
|
}
|
|
|
|
// Initialize any miscellenous operating system settings that need to be
|
|
// set for the class libraries.
|
|
//
|
|
public static void initializeOSEnvironment() {
|
|
}
|
|
|
|
/* Current count of objects pending for finalization */
|
|
private static volatile int finalRefCount = 0;
|
|
|
|
/* Peak count of objects pending for finalization */
|
|
private static volatile int peakFinalRefCount = 0;
|
|
|
|
/*
|
|
* Gets the number of objects pending for finalization.
|
|
*
|
|
* @return the number of objects pending for finalization.
|
|
*/
|
|
public static int getFinalRefCount() {
|
|
return finalRefCount;
|
|
}
|
|
|
|
/*
|
|
* Gets the peak number of objects pending for finalization.
|
|
*
|
|
* @return the peak number of objects pending for finalization.
|
|
*/
|
|
public static int getPeakFinalRefCount() {
|
|
return peakFinalRefCount;
|
|
}
|
|
|
|
/*
|
|
* Add <tt>n</tt> to the objects pending for finalization count.
|
|
*
|
|
* @param n an integer value to be added to the objects pending
|
|
* for finalization count
|
|
*/
|
|
public static void addFinalRefCount(int n) {
|
|
// The caller must hold lock to synchronize the update.
|
|
|
|
finalRefCount += n;
|
|
if (finalRefCount > peakFinalRefCount) {
|
|
peakFinalRefCount = finalRefCount;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns Thread.State for the given threadStatus
|
|
*/
|
|
public static Thread.State toThreadState(int threadStatus) {
|
|
if ((threadStatus & JVMTI_THREAD_STATE_RUNNABLE) != 0) {
|
|
return RUNNABLE;
|
|
} else if ((threadStatus & JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER) != 0) {
|
|
return BLOCKED;
|
|
} else if ((threadStatus & JVMTI_THREAD_STATE_WAITING_INDEFINITELY) != 0) {
|
|
return WAITING;
|
|
} else if ((threadStatus & JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT) != 0) {
|
|
return TIMED_WAITING;
|
|
} else if ((threadStatus & JVMTI_THREAD_STATE_TERMINATED) != 0) {
|
|
return TERMINATED;
|
|
} else if ((threadStatus & JVMTI_THREAD_STATE_ALIVE) == 0) {
|
|
return NEW;
|
|
} else {
|
|
return RUNNABLE;
|
|
}
|
|
}
|
|
|
|
/* The threadStatus field is set by the VM at state transition
|
|
* in the hotspot implementation. Its value is set according to
|
|
* the JVM TI specification GetThreadState function.
|
|
*/
|
|
private final static int JVMTI_THREAD_STATE_ALIVE = 0x0001;
|
|
private final static int JVMTI_THREAD_STATE_TERMINATED = 0x0002;
|
|
private final static int JVMTI_THREAD_STATE_RUNNABLE = 0x0004;
|
|
private final static int JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER = 0x0400;
|
|
private final static int JVMTI_THREAD_STATE_WAITING_INDEFINITELY = 0x0010;
|
|
private final static int JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT = 0x0020;
|
|
|
|
static {
|
|
initialize();
|
|
}
|
|
private native static void initialize();
|
|
}
|