Glossary

An HPjmeter JVM agent that is part of an open console session and is collecting data from the JVM and application and is sending it to a console.

A module that represents HPjmeter in your environment. HPjmeter provides two types of agents, a node agent and a JVM agent.

An HPjmeter JVM agent that is installed, configured, and is collecting data, but is not connected to a console and is not part of a session. The collected data is stored in a file on the managed node that you can open later from the console.

See bytecode instrumentation.

Instrumentation of Java bytecode inserts a special, short sequence of bytecode at designated points in the Java classes of an application to facilitate runtime analysis of those classes during monitoring.

A session created when a running JVM terminates on its own, or when you close an active session. The data in a cached session is available for analysis, but it is no longer connected to a running JVM and is no longer collecting additional data.

Displays the capture of “call” relationships between the methods. The nodes of the call graph represent the program methods, while the directed arcs represent calls made from one method to another. In a call graph, the call counts or the timing data are collected for the arcs.

Call graph data presented in a collapsible and expandable tree hierarchy. See also call graph.

The time as measured by an external independent clock.

The measure of reliance or assurance that HPjmeter diagnosed the situation correctly.

The HPjmeter graphical representation of probability that the displayed values are correct. As the number of samples taken increases, the probability increases.

The main window containing the menu and button controls for monitoring live applications and analyzing captured data.

The session preferences window allows you to specify the classes to measure when you open a session with a JVM agent. Console filters can be changed from session to session, but not during a session. For details, see Controlling Data Collection and Display

Time spent by any central processing unit (CPU) to execute a thread.

Times when a thread is runnable, but not necessarily running. Depending on the actual hardware, operating system, and Java VM, this time may also include I/O time, but generally CPU virtual times are a good approximation of real CPU time consumed by the application.

The calculated rate at which new objects are occupying the heap.

An HPjmeter JVM agent that is installed and configured, but is not part of an open console session and is, therefore, not collecting data from the JVM and applications and is not sending data to a console.

That part of the heap where new and/or short-lived objects (the young generation) are created and used.

The accumulated total times used by a method, but not including the time used by the methods that were called from it.

To exclude the measurement of specified classes. HPjmeter provides two methods to control how information is collected and displayed, JVM Agent Filters and console filters. For details, see Controlling Data Collection and Display

The process of automatically freeing memory by removing objects that are no longer referenced by the program.

A section of code, typically a method, with a higher-than-normal level of execution or access requiring high CPU usage.

The accumulated total time used by all invocations of the method and all methods that were called from it directly or indirectly.

Replacing a call to a function with an instance of the function; usually done at compile time.

Java Management Extensions. API for managing and monitoring applications, devices, services, and JVMs. For API specifics, see the Java Community Process web: Java Management Extensions (JMX) Specification (JSR3) and JMX Remote Specification (JSR160).

A module running on each managed node that collects data and sends it to the node agent, which sends it to the console.

The include and exclude options to the JVM agent allow you to filter metrics by class name. For details, see Controlling Data Collection and Display

accumulated live objects that clog the heap, creating memory leaks.

The summary time measured from the moment the thread requests a Java lock until the lock is actually granted.

The time elapsed between the moment a thread tries to acquire a lock and the time the thread enters the monitor.

A computer on which the HPjmeter node agent and JVM agent are installed.

HPjmeter uses the long term linear upward trends in the heap size after garbage collections to calculate the likely presence of memory leaks. See How Memory Leak Detection Works

Objects needed by the Java interpreter and for reflection in garbage collection.

A function defined in a class. Unless specified otherwise, a method is not static.

The number of times each function (method) of the program was called during a run.

The actual time spent in each of the methods of the program.

In this context, a mapping that associates numerical values with static or dynamic elements such as program functions, variables, classes, objects, types, or threads.

A process that manages communication between JVM agents and a console. Node Agent

Objects in the heap that have survived a successive number of garbage collections, and have been moved to the old space in the heap.

A group of types. Packages are declared with the package keyword.

Accumulating data during tracing such that consecutive calls from the same caller to the same callee increase the recorded time value for a call.

Incremental, lightweight garbage collection of primarily short-lived objects in order to free space.

The breadth of view across thread-based profile data. HPjmeter lets you look at a single thread, a group of threads, or the entire application.

service-level objective. A service-level objective (SLO) partitions a service-level agreement (SLA) into metrics and operational information to enforce and/or monitor the SLA.

An open, live connection between an console and a JVM agent running on a managed node. An open session has associated with it a set of metrics, filters, and alerts that are configured when you open the session.

The measure of the expected impact of the detected situation on the application stability.

See service-level objective.

Duration of a full garbage collection where processing stops during the collection time.

Excessive paging due to a disparity between physical memory actually available to the application and the specified maximum size for memory usage. 

When profiling, the distribution of thread lifetime over the possible thread states.

Time slice entries represent the life span of the current monitoring session for an application. You can view data throughout the life span of a time slice. 

Optional structure within the heap that is intermediate between the eden space and the old space. The train is a related collection of smaller memory spaces (cars) that have garbage collected incrementally according to the train algorithm.

Mathematical formula that describes incremental garbage collection of related old objects. The purpose of train garbage collection is to reduce the length of pause due to GC that is visible to users of the software.

The popup screens where you see graphical or tabular displays of data. Visualizers provide contextual controls based on the data displayed. See Using Visualizer Tool bars

New and/or short-lived objects in the heap. Usually garbage collections are done frequently in the young generation by scavenging the eden space.