WebLogic Server 8.1 API Reference: Interface JRockitRuntimeMBean

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

BEA Systems, Inc.

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: INNER | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

WebLogic Server 8.1 API Reference

weblogic.management.runtime
Interface JRockitRuntimeMBean

public interface JRockitRuntimeMBean
extends weblogic.management.runtime.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.

Author:: Copyright © 2002 BEA Systems, Inc. All Rights Reserved.

Method Summary
`double`	`getAllProcessorsAverageLoad()` Displays a snapshot of the average load of all processors in the host computer.
`long`	`getConstructorInvocationCount(java.lang.reflect.Constructor constructor)` Indicates the number of times a constructor has been invoked since enabling invocation counting.
`long`	`getConstructorTiming(java.lang.reflect.Constructor constructor)` Indicates the amount of time (in milliseconds) the Virtual Machine has spent in the constructor since enabling time measuring.
`long`	`getExceptionCount(java.lang.Class throwableClass)` Indicates the number of times an exception type has been thrown since enabling excpetion counting.
`long`	`getFreeHeap()` Indicates the amount (in bytes) of Java heap memory that is currently free in the Virtual Machine.
`long`	`getFreePhysicalMemory()` Indicates the amount (in bytes) of physical memory that is currently free on the host computer.
`java.lang.String`	`getGcAlgorithm()` Indicates the type of garbage collector (GC) that the Virtual Machine is using.
`java.lang.String`	`getJVMDescription()` Describes the Java Virtual Machine.
`double`	`getJvmProcessorLoad()` Returns a snapshot of the load that the Virutal Machine is placing on all processors in the host computer.
`long`	`getLastGCEnd()` Indicates the time at which the last garbage collection run ended.
`long`	`getLastGCStart()` Indicates the time at which the last garbage collection run started.
`long`	`getMethodInvocationCount(java.lang.reflect.Method method)` Indicates the number of times a method has been invoked since enabling invocation counting.
`long`	`getMethodTiming(java.lang.reflect.Method method)`
`java.lang.String`	`getName()` Indicates the name of the Java Virtual Machine.
`int`	`getNumberOfDaemonThreads()` Indicates the number of daemon Java threads currently running in the Virtual Machine across all processors.
`int`	`getNumberOfProcessors()` Displays the number of processors on the Virtual Machine's host computer.
`java.lang.String`	`getThreadStackDump()` Provides a stack dump of all live threads in the Virtual Machine (VM).
`long`	`getTotalGarbageCollectionCount()` Indicates the number of garbage collection runs that have occurred since the Virtual Machine was started.
`long`	`getTotalGarbageCollectionTime()` Indicates the number of milliseconds that the Virtual Machine has spent on all garbage collection runs since the VM was started.
`long`	`getTotalHeap()` Indicates the amount (in bytes) of memory currently allocated to the Virtual Machine's Java heap.
`int`	`getTotalNumberOfThreads()` Indicates the number of Java threads (daemon and non-daemon) that are currently running in the Virtual Machine across all processors.
`long`	`getTotalNurserySize()` Indicates the amount (in bytes) of memory that is currently allocated to the nursery.
`long`	`getTotalPhysicalMemory()` Indicates the amount (in bytes) of physical memory on the host computer.
`long`	`getUptime()` Indicates the number of milliseconds that the Virtual Machine has been running.
`long`	`getUsedHeap()` Indicates the amount (in bytes) of Java heap memory that is currently being used by the Virtual Machine.
`long`	`getUsedPhysicalMemory()` Indicates the amount (in bytes) of physical memory that is currently being used on the host computer.
`java.lang.String`	`getVendor()` Indicates the name of the JVM vendor.
`java.lang.String`	`getVersion()` Indicates the current version of Java Virtual Machine.
`boolean`	`isConcurrent()` Indicates whether the VM's garbage collector runs in a separate Java thread concurrently with other Java threads.
`boolean`	`isConstructorInvocationCountEnabled(java.lang.reflect.Constructor cons)` Indicates whether the Virtual Machine counts how many times a constructor is invoked.
`boolean`	`isConstructorTimingEnabled(java.lang.reflect.Constructor constructor)` Indicates whether the Virtual Machine measures how much time it spends in a constructor.
`boolean`	`isExceptionCountEnabled(java.lang.Class throwableClass)` Indicates whether the Virtual Machine counts how many times an exception is thrown.
`boolean`	`isGCHandlesCompaction()` Indicates whether the VM's garbage collector compacts the Java heap.
`boolean`	`isGenerational()` Indicates whether the VM's garbage collector uses a nursery space.
`boolean`	`isIncremental()` 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.
`boolean`	`isMethodInvocationCountEnabled(java.lang.reflect.Method method)` Indicates whether the Virtual Machine counts how many times a method is invoked.
`boolean`	`isMethodTimingEnabled(java.lang.reflect.Method method)` Indicates whether the Virtual Machine measures how much time it spends in a method.
`boolean`	`isParallel()` Indicates whether the VM's garbage collector is able to run in parallel on multiple processors if multiple processors are available.

Methods inherited from interface weblogic.management.WebLogicMBean

getMBeanInfo, 
getObjectName, 
getParent, 
getType, 
isCachingDisabled, 
isRegistered, 
setName, 
setParent

Methods inherited from interface javax.management.DynamicMBean

getAttribute, 
getAttributes, 
invoke, 
setAttribute, 
setAttributes

Methods inherited from interface javax.management.MBeanRegistration

postDeregister, 
postRegister, 
preRegister

Methods inherited from interface javax.management.NotificationBroadcaster

addNotificationListener, 
getNotificationInfo, 
removeNotificationListener

Method Detail

getTotalPhysicalMemory

public long getTotalPhysicalMemory()

Indicates the amount (in bytes) of physical memory on the host computer. The value does not include memory that an operating makes available through swap space on a disk or other types of virtual memory.

Returns:: Bytes of physical memory on the host computer.

getFreePhysicalMemory

public long getFreePhysicalMemory()

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

Returns:: Bytes of free physical memory.

getUsedPhysicalMemory

public long getUsedPhysicalMemory()

Indicates the amount (in bytes) of physical memory that is currently being used on the host computer. This method reports 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

public long getTotalHeap()

Indicates 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 value returned by #getMaxHeap().

Returns:: Bytes of memory allocated to the Java heap.

getFreeHeap

public long getFreeHeap()

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

Returns:: Bytes of free Java heap memory.

getUsedHeap

public long getUsedHeap()

Indicates 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

public long getTotalNurserySize()

Indicates 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

public java.lang.String getGcAlgorithm()

Indicates 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

public long getTotalGarbageCollectionCount()

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

Returns:: The number of GCs perfomed so far.

getLastGCStart

public long getLastGCStart()
                    throws com.bea.jvm.NotAvailableException

Indicates the time at which the last garbage collection run started.

Returns:: The time the last GC started.
Throws:: com.bea.jvm.NotAvailableException - Description of the Exception

getLastGCEnd

public long getLastGCEnd()
                  throws com.bea.jvm.NotAvailableException

Indicates the time at which the last garbage collection run ended.

Returns:: the time the last GC ended.
Throws:: com.bea.jvm.NotAvailableException - Description of the Exception

getTotalGarbageCollectionTime

public long getTotalGarbageCollectionTime()
                                   throws com.bea.jvm.NotAvailableException

Indicates 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:: com.bea.jvm.NotAvailableException - Description of the Exception

isGCHandlesCompaction

public boolean isGCHandlesCompaction()
                              throws com.bea.jvm.NotAvailableException

Indicates whether the VM's garbage collector compacts the Java heap. Usually the heap is scattered throughtout 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:: com.bea.jvm.NotAvailableException - Description of the Exception

isConcurrent

public boolean isConcurrent()
                     throws com.bea.jvm.NotAvailableException

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:: com.bea.jvm.NotAvailableException - Description of the Exception

isGenerational

public boolean isGenerational()
                       throws com.bea.jvm.NotAvailableException

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:: com.bea.jvm.NotAvailableException - Description of the Exception

isIncremental

public boolean isIncremental()
                      throws com.bea.jvm.NotAvailableException

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:: com.bea.jvm.NotAvailableException - Description of the Exception

isParallel

public boolean isParallel()
                   throws com.bea.jvm.NotAvailableException

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:: com.bea.jvm.NotAvailableException - Description of the Exception

isMethodTimingEnabled

public boolean isMethodTimingEnabled(java.lang.reflect.Method method)
                              throws com.bea.jvm.UnapplicableMethodException

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:: com.bea.jvm.UnapplicableMethodException - Description of the Exception

getMethodTiming

public long getMethodTiming(java.lang.reflect.Method method)
                     throws com.bea.jvm.UnapplicableMethodException

isMethodInvocationCountEnabled

public boolean isMethodInvocationCountEnabled(java.lang.reflect.Method method)
                                       throws com.bea.jvm.UnapplicableMethodException

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:: com.bea.jvm.UnapplicableMethodException - Description of the Exception

getMethodInvocationCount

public long getMethodInvocationCount(java.lang.reflect.Method method)
                              throws com.bea.jvm.UnapplicableMethodException

Indicates 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:: com.bea.jvm.UnapplicableMethodException - Description of the Exception

isConstructorTimingEnabled

public boolean isConstructorTimingEnabled(java.lang.reflect.Constructor constructor)
                                   throws com.bea.jvm.UnapplicableMethodException

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:: com.bea.jvm.UnapplicableMethodException - Description of the Exception

getConstructorTiming

public long getConstructorTiming(java.lang.reflect.Constructor constructor)
                          throws com.bea.jvm.UnapplicableMethodException

Indicates 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:: com.bea.jvm.UnapplicableMethodException - Description of the Exception

isConstructorInvocationCountEnabled

public boolean isConstructorInvocationCountEnabled(java.lang.reflect.Constructor cons)
                                            throws com.bea.jvm.UnapplicableMethodException

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

Parameters:: Constructor - the constructor you want to check.
Returns:: boolean true if invocation counting is enabled for the constructor.
Throws:: com.bea.jvm.UnapplicableMethodException - Description of the Exception

getConstructorInvocationCount

public long getConstructorInvocationCount(java.lang.reflect.Constructor constructor)
                                   throws com.bea.jvm.UnapplicableMethodException

Indicates 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:: com.bea.jvm.UnapplicableMethodException - Description of the Exception

isExceptionCountEnabled

public boolean isExceptionCountEnabled(java.lang.Class throwableClass)
                                throws java.lang.ClassCastException

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:: java.lang.ClassCastException - thrown if the argument is not a subclass of Throwable

getExceptionCount

public long getExceptionCount(java.lang.Class throwableClass)

Indicates the number of times an exception type has been thrown since enabling excpetion 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

public int getTotalNumberOfThreads()

Indicates 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

public int getNumberOfDaemonThreads()

Indicates 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.

getThreadStackDump

public java.lang.String getThreadStackDump()

Provides a stack dump of all live threads in the Virtual Machine (VM). This is similar to typing CTRL-break in the shell process that is running the VM.

Returns:: a stack dump of all live threads in the VM.

getUptime

public long getUptime()

Indicates the number of milliseconds that the Virtual Machine has been running.

Returns:: The uptime (in milliseconds) of the VM.

getJVMDescription

public java.lang.String getJVMDescription()

Describes the Java Virtual Machine. For example, "BEA WebLogic JRockit Java Virtual Machine."

Returns:: A description of the JVM as a String.

getVendor

public java.lang.String getVendor()

Indicates the name of the JVM vendor. For example, "BEA Systems Inc."

Returns:: The name of the vendor as a String.

getVersion

public java.lang.String getVersion()

Indicates the current version of Java Virtual Machine.

Returns:: The current version of the JVM as a String.

getName

public java.lang.String getName()

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

Returns:: The JVM name as a String.

getNumberOfProcessors

public int getNumberOfProcessors()

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

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

getAllProcessorsAverageLoad

public double getAllProcessorsAverageLoad()

Displays 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

public double getJvmProcessorLoad()

Returns a snapshot of the load that the Virutal 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.