weblogic.management.runtime
Interface JRockitRuntimeMBean

All Superinterfaces:

JVMRuntimeMBean

public interface JRockitRuntimeMBean
extends JVMRuntimeMBean

Exposes runtime data about the JRockit Virtual Machine (VM) that is running the current WebLogic Server instance. You cannot change the VM's operating parameters while the VM is active. Instead, use the startup options that are described in the JRockit documentation.

The WebLogic JVM contains only one of these Runtime MBeans:

• If the JVM is an instance of a JRockit JDK, then the JVM contains JRockitRuntime MBean.

• Otherwise, it contains the JVMRuntimeMBean.

Deprecation of MBeanHome and Type-Safe Interfaces

This is a type-safe interface for a WebLogic Server MBean, which you can import into your client classes and access through weblogic.management.MBeanHome. As of 9.0, the MBeanHome interface and all type-safe interfaces for WebLogic Server MBeans are deprecated. Instead, client classes that interact with WebLogic Server MBeans should use standard JMX design patterns in which clients use the javax.management.MBeanServerConnection interface to discover MBeans, attributes, and attribute types at runtime. For more information, see "Developing Manageable Applications with JMX" on http://www.oracle.com/technology/products/weblogic/index.html.

getTotalPhysicalMemory

long getTotalPhysicalMemory()

The amount (in bytes) of physical memory on the host computer.

The value does not include memory that an operating system makes available through swap space on a disk or other types of virtual memory.

Returns:

Bytes of physical memory on the host computer.

getFreePhysicalMemory

long getFreePhysicalMemory()

The amount (in bytes) of physical memory that is currently free on the host computer.

Returns:

Bytes of free physical memory.

getUsedPhysicalMemory

long getUsedPhysicalMemory()

The amount (in bytes) of physical memory that is currently being used on the host computer.

The value describes the memory that is being used by all processes on the computer, not just by the Virtual Machine.

Returns:

Bytes of physical memory being used.

getTotalHeap

long getTotalHeap()

The amount (in bytes) of memory currently allocated to the Virtual Machine's Java heap.

This value, which is also known as the "heap size," may grow up to the specified maximum heap size.

Returns:

Bytes of memory allocated to the Java heap.

See Also:

JRockitRuntimeMBean.getMaxHeapSize()

getFreeHeap

long getFreeHeap()

The amount (in bytes) of Java heap memory that is currently free in the Virtual Machine.

Returns:

Bytes of free Java heap memory.

getUsedHeap

long getUsedHeap()

The amount (in bytes) of Java heap memory that is currently being used by the Virtual Machine.

Returns:

Bytes of Java heap memory that is being used.

getTotalNurserySize

long getTotalNurserySize()

The amount (in bytes) of memory that is currently allocated to the nursery.

The nursery is the area of the Java heap that the VM allocates to most objects. Instead of garbage collecting the entire heap, generational garbage collectors focus on the nursery. Because most objects die young, most of the time it is sufficient to garbage collect only the nursery and not the entire heap.

If you are not using a generational garbage collector, the nursery size is 0.

Returns:

Bytes allocated to the nursery.

getGcAlgorithm

String getGcAlgorithm()

The type of garbage collector (GC) that the Virtual Machine is using.

JRockit provides the following types of GCs:

• Generational Copying, which is suitable for testing applications on a desktop machine with a small (less then 128 MB) heap.

• Single Spaced Concurrent, which reduces or eliminates pauses in the VM that are due to garbage collection. Because it trades memory throughput for reduced pause time, you generally need a larger heap size than with other GC types. If your ordinary Java threads create more garbage than this GC can collect, the VM will pause while the Java threads wait for the garbage collection to finish.

• Generational Concurrent, which creates a "nursery" space within the heap. New objects are created within the nursery. When the nursery is full, JRockit "stops-the-world," removes the dead objects from the nursery, and moves live objects to a different space within the heap. Another thread runs in the background to remove dead objects from the non-nursery space. This GC type has a higher memory throughput than a single spaced concurrent GC.

• Parallel, which allocates all objects to a single spaced heap. When the heap is full, all Java threads are stopped and every CPU is used to perform a complete garbage collection of the entire heap. This behavior causes longer pause times than for the concurrent collectors but maximizes memory throughput.

Returns:

Type of garbage collector being used by the VM.

getTotalGarbageCollectionCount

long getTotalGarbageCollectionCount()

The number of garbage collection runs that have occurred since the Virtual Machine was started.

Returns:

The number of GCs perfomed so far.

getLastGCStart

long getLastGCStart()
                    throws NotFoundException

The time at which the last garbage collection run started.

Returns:

The time the last GC started.

Throws:

NotFoundException

getLastGCEnd

long getLastGCEnd()
                  throws NotFoundException

The time at which the last garbage collection run ended.

Returns:

the time the last GC ended.

Throws:

NotFoundException

getTotalGarbageCollectionTime

long getTotalGarbageCollectionTime()
                                   throws NotFoundException

The number of milliseconds that the Virtual Machine has spent on all garbage collection runs since the VM was started.

Returns:

Total milliseconds spent for all garbage collection runs.

Throws:

NotFoundException

isGCHandlesCompaction

boolean isGCHandlesCompaction()
                              throws NotFoundException

Indicates whether the VM's garbage collector compacts the Java heap.

Usually the heap is scattered throughout available memory. A garbage collector that compacts the heap defragments the memory space in addition to deleting unused objects.

Returns:

true if this garbage collector compacts the Java heap.

Throws:

NotFoundException

isConcurrent

boolean isConcurrent()
                     throws NotFoundException

Indicates whether the VM's garbage collector runs in a separate Java thread concurrently with other Java threads.

Returns:

true if this GC runs in a separate concurrent thread.

Throws:

NotFoundException

isGenerational

boolean isGenerational()
                       throws NotFoundException

Indicates whether the VM's garbage collector uses a nursery space.

A nursery is the area of the Java heap that the VM allocates to most objects. Instead of garbage collecting the entire heap, generational garbage collectors focus on the nursery. Because most objects die young, most of the time it is sufficient to garbage collect only the nursery and not the entire heap.

Returns:

true if this GC has a nursery.

Throws:

NotFoundException

isIncremental

boolean isIncremental()
                      throws NotFoundException

Indicates whether the VM's garbage collector collects (increments) garbage as it scans the memory space and dumps the garbage at the end of its cycle.

With a non-incremental garbage collector, garbage is dumped as soon as it is encountered.

Returns:

true if this GC is incremental.

Throws:

NotFoundException

isParallel

boolean isParallel()
                   throws NotFoundException

Indicates whether the VM's garbage collector is able to run in parallel on multiple processors if multiple processors are available.

Returns:

true if this GC runs in parallel on multiple processors.

Throws:

NotFoundException

isMethodTimingEnabled

boolean isMethodTimingEnabled(Method method)
                              throws NotFoundException

Deprecated. 10.0.0.0 There will be no replacement for this method in future, since it will not be supported by JRockit management API.

Indicates whether the Virtual Machine measures how much time it spends in a method.

Parameters:

method - the method you want to check.

Returns:

boolean true if time measuring is enabled for the method.

Throws:

NotFoundException

getMethodTiming

long getMethodTiming(Method method)
                     throws NotFoundException

Deprecated. 10.0.0.0 There will be no replacement for this method in future, since it will not be supported by JRockit management API.

The amount of time (in milliseconds) the Virtual Machine has spent in the method since enabling time measuring.

If time measuring has not been enabled for the specified method, this method returns a null value.

Parameters:

Method - the method we wish to check.

Returns:

long cumulative milliseconds spent in the method.

Throws:

NotFoundException

isMethodInvocationCountEnabled

boolean isMethodInvocationCountEnabled(Method method)
                                       throws NotFoundException

Deprecated. 10.0.0.0 There will be no replacement for this method in future, since it will not be supported by JRockit management API.

Indicates whether the Virtual Machine counts how many times a method is invoked.

Parameters:

method - the method you want to check.

Returns:

boolean true if invocation counting is enabled for the method.

Throws:

NotFoundException

getMethodInvocationCount

long getMethodInvocationCount(Method method)
                              throws NotFoundException

Deprecated. 10.0.0.0 There will be no replacement for this method in future, since it will not be supported by JRockit management API.

The number of times a method has been invoked since enabling invocation counting.

Parameters:

method - the method you want to check.

Returns:

long the invocaton count for the specified Method.

Throws:

NotFoundException

isConstructorTimingEnabled

boolean isConstructorTimingEnabled(Constructor constructor)
                                   throws NotFoundException

Deprecated. 10.0.0.0 There will be no replacement for this method in future, since it will not be supported by JRockit management API.

Indicates whether the Virtual Machine measures how much time it spends in a constructor.

Parameters:

constructor - the constructor you want to check.

Returns:

boolean true if time measuring is enabled for the constructor.

Throws:

NotFoundException

getConstructorTiming

long getConstructorTiming(Constructor constructor)
                          throws NotFoundException

Deprecated. 10.0.0.0 There will be no replacement for this method in future, since it will not be supported by JRockit management API.

The amount of time (in milliseconds) the Virtual Machine has spent in the constructor since enabling time measuring.

If time measuring hasn't been enabled for the specified constructor, this method returns a null value.

Parameters:

constructor - the constructor you want to check.

Returns:

long cumulative milliseconds spent in the constructor.

Throws:

NotFoundException

isConstructorInvocationCountEnabled

boolean isConstructorInvocationCountEnabled(Constructor cons)
                                            throws NotFoundException

Deprecated. 10.0.0.0 There will be no replacement for this method in future, since it will not be supported by JRockit management API.

Indicates whether the Virtual Machine counts how many times a constructor is invoked.

Parameters:

cons - the constructor you want to check.

Returns:

boolean true if invocation counting is enabled for the constructor.

Throws:

NotFoundException

getConstructorInvocationCount

long getConstructorInvocationCount(Constructor constructor)
                                   throws NotFoundException

Deprecated. 10.0.0.0 There will be no replacement for this method in future, since it will not be supported by JRockit management API.

The number of times a constructor has been invoked since enabling invocation counting.

Parameters:

constructor - - the constructor for which to return the invocation count.

Returns:

long the invocaton count for the specified constructor.

Throws:

NotFoundException

isExceptionCountEnabled

boolean isExceptionCountEnabled(Class throwableClass)
                                throws ClassCastException

Deprecated. 10.0.0.0 There will be no replacement for this method in future, since it will not be supported by JRockit management API.

Indicates whether the Virtual Machine counts how many times an exception is thrown.

Parameters:

throwableClass - the exception class to get the counter for.

Returns:

true if exception counting is enabled for the argument, false otherwise.

Throws:

ClassCastException - thrown if the argument is not a subclass of Throwable

getExceptionCount

long getExceptionCount(Class throwableClass)

Deprecated. 10.0.0.0 There will be no replacement for this method in future, since it will not be supported by JRockit management API.

The number of times an exception type has been thrown since enabling exception counting. If exception counting has not been enabled for the specified type, the result is unspecified.

Parameters:

throwableClass - the exception class to get the counter for. If the throwableClass is null, a NullPointerException will be thrown.

Returns:

long the current number of exceptions of this type thrown.

getTotalNumberOfThreads

int getTotalNumberOfThreads()

The number of Java threads (daemon and non-daemon) that are currently running in the Virtual Machine across all processors.

Returns:

the number of Java threads running in the VM.

getNumberOfDaemonThreads

int getNumberOfDaemonThreads()

The number of daemon Java threads currently running in the Virtual Machine across all processors.

Returns:

the total number of daemon Java threads running in the VM.

getJVMDescription

String getJVMDescription()

A description of the Java Virtual Machine. For example, "BEA WebLogic JRockit Java Virtual Machine."

Returns:

A description of the JVM as a String.

getVendor

String getVendor()

The name of the JVM vendor.

Returns:

The name of the vendor as a String.

getVersion

String getVersion()

The current version of Java Virtual Machine.

Returns:

The current version of the JVM as a String.

getName

String getName()

The name of the Java Virtual Machine. For example, "WebLogic JRockit."

Returns:

The JVM name as a String.

getNumberOfProcessors

int getNumberOfProcessors()

The number of processors on the Virtual Machine's host computer. If this is not a Symmetric Multi Processor (SMP) system, the value will be 1.

Returns:

The number of processors on the VM's host computer.

getAllProcessorsAverageLoad

double getAllProcessorsAverageLoad()

A snapshot of the average load of all processors in the host computer. If the computer has only one processor, this method returns the same value as getJvmProcessorLoad(0).

The value is returned as a double, where 1.0 represents 100% load (no idle time) and 0.0 represents 0% load (pure idle time).

Returns:

a double that represents a snapshot of the average load of all processors.

See Also:

#getProcessorLoad(int)

getJvmProcessorLoad

double getJvmProcessorLoad()

A snapshot of the load that the Virtual Machine is placing on all processors in the host computer. If the host contains multiple processors, the value represents a snapshot of the average load.

The value is returned as a double, where 1.0 represents 100% load (no idle time) and 0.0 represents 0% load (pure idle time).

Returns:

a double that indicates the average load that the VM is placing on all processors.