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 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 © 2004 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.runtime.JVMRuntimeMBean
`getHeapFreeCurrent, getHeapSizeCurrent, getJavaVendor, getJavaVersion, getJavaVMVendor, getOSName, getOSVersion`

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 NotFoundException

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

  Returns:
    The time the last GC started.
  Throws:
    NotFoundException -

### getLastGCEnd

    public long getLastGCEnd()
                      throws NotFoundException

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

  Returns:
    the time the last GC ended.
  Throws:
    NotFoundException -

### getTotalGarbageCollectionTime

    public long getTotalGarbageCollectionTime()
                                       throws NotFoundException

  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:
    NotFoundException -

### isGCHandlesCompaction

    public boolean isGCHandlesCompaction()
                                  throws NotFoundException

  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:
    NotFoundException -

### isConcurrent

    public 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

    public 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

    public 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

    public 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

    public boolean isMethodTimingEnabled(java.lang.reflect.Method method)
                                  throws NotFoundException

  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

    public long getMethodTiming(java.lang.reflect.Method method)
                         throws NotFoundException

### isMethodInvocationCountEnabled

    public boolean isMethodInvocationCountEnabled(java.lang.reflect.Method method)
                                           throws NotFoundException

  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

    public long getMethodInvocationCount(java.lang.reflect.Method method)
                                  throws NotFoundException

  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:
    NotFoundException -

### isConstructorTimingEnabled

    public boolean isConstructorTimingEnabled(java.lang.reflect.Constructor constructor)
                                       throws NotFoundException

  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

    public long getConstructorTiming(java.lang.reflect.Constructor constructor)
                              throws NotFoundException

  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:
    NotFoundException -

### isConstructorInvocationCountEnabled

    public boolean isConstructorInvocationCountEnabled(java.lang.reflect.Constructor cons)
                                                throws NotFoundException

  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

    public long getConstructorInvocationCount(java.lang.reflect.Constructor constructor)
                                       throws NotFoundException

  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:
    NotFoundException -

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

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Documentation is available at http://e-docs.bea.com/wls/docs81
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD