What is Oracle JRockit Real Time?

Oracle JRockit Real Time provides lightweight, front-office infrastructure for low latency, event-driven applications. For companies in highly-competitive environments where performance is key and every millisecond counts, JRockit Real Time provides the first Java-based real-time computing infrastructure.

For example, for certain types of applications, particularly in the Telecom and Finance industries, stringent requirements are placed on transaction latency. When these applications are written in Java, the unpredictable pause times caused by garbage collection can have a profound and potentially harmful affect on this latency.

For this reason, Oracle JRockit Real Time’s proprietary Oracle JRockit JVM R27.6 features deterministic garbage collection, a dynamic garbage collection priority that ensures extremely short pause times and limits the total number of those pauses within a prescribed window. Such short pauses can greatly lessen the lessen the impact of the deterministic garbage collection when compared to running a normal garbage collection.

Oracle JRockit Real Time Compatibility

Oracle JRockit Real Time 3.1.0 is fully compatible with Oracle JRockit JDK R27.6 and all applications certified with the latter will work on the former without need for additional certification. This means that all Oracle applications supported by Oracle JRockit JDK R27.6 (whether Java 1.4.2-, 5.0- or 6-based) are also supported with Oracle JRockit Real Time 3.1.0.

Oracle JRockit Real Time 3.1.0 also supports standalone Java applications running on Java SE 6 and J2SE 1.4.2 and 5.0 runtime environments, as well as Spring Framework-based applications, as described in Software Components.

Oracle JRockit Real Time 3.1.0 performance still depends upon application type and size, so you will need to verify that you applications meet the base requirements on hardware, heap size and other metrics for optimal performance.

Oracle JRockit JDK Features in JRockit Real Time 3.1.0

JRockit Real Time 3.1.0 is bundled with the following versions of the Oracle JRockit JDK:

Oracle JRockit JDK 6 Update 11

Oracle JRockit JDK 5.0 Update 17

Oracle JRockit JDK 1.4.2_19

These versions of the Oracle JRockit JDK are included in Oracle JRockit Mission Control, which is a suite of tools designed to monitor, manage, profile, and gain insight into problems occurring in your Java application without requiring the performance overhead normally associated with these types of tools.

JRockit Mission Control includes the following two tools that are of particular interest to Oracle JRockit Real Time 3.1.0 users:

JRockit Latency Analysis Tool

The Latency Analysis Tool (LAT), part of the JRockit Runtime Analyzer (JRA) helps you work your way down to a Java application latency. You can use the Latency Graph to visually see how a Java application that contains latencies looks like. This tool gives you great flexibility to pinpoint where in the code waits and other latencies occur.

To record latency data, you need to create a JRA recording. Before you start the JRA recording, you must select one of the Latency Recording profiles in order to record latency data.

See Oracle JRockit Runtime Analyzer for additional information about using the latency analyzer and JRA recordings to record latency data. After you launch Oracle JRockit Mission Control, you can also access additional documentation about this feature using online help.

JRockit Memory Leak Detector

The JRockit Memory Leak Detector is a tool for discovering and finding the cause for memory leaks in a Java application. The JRockit Memory Leak Detector's trend analyzer discovers slow leaks, it shows detailed heap statistics (including referring types and instances to leaking objects), allocation sites, and it provides a quick drill down to the cause of the memory leak. The Memory Leak Detector uses advanced graphical presentation techniques to make it easier to navigate and understand the sometimes complex information.

See Introduction to JRockit Memory Leak Detector for additional information about using the memory leak detector. After you launch JRockit Mission Control, you can also access additional documentation about this feature using online help.

Starting JRockit Mission Control

To start JRockit Mission Control, follow these steps:

Ensure that your JAVA_HOME environment variable points to the root folder of the Oracle JRockit JDK included in JRockit Real Time 3.1.0.

Use this command for Windows platforms:

Note:

This example assumes that you are using the Windows Command Prompt (DOS) or compatible command shell and have selected the default product installation directory.

set JAVA_HOME=%ProgramFiles%\JRockit Real Time \wlrt<wlrt_version>-<java_version>\bin

Use this command for Linux and Solaris platforms:

Note:

This example assumes that you are using the UNIX bash shell or compatible command shell and have selected the default product installation directory.

export JAVA_HOME=$HOME/wlrt<wlrt_version>-<java_version>/bin

Open up a command window.

Run the jrmc executable file, located in the %JAVA_HOME%\bin directory:

(Windows) prompt> %JAVA_HOME%\bin\jrmc

(Linux) prompt> ${JAVA_HOME}/bin/jrmc

Example Use Cases

These use cases provide examples of how JRockit Real Time can provide solutions for high-performance environments with response-time sensitive applications.

Derivative Exchange Defies Arbitrage Traders

An investment arm of a large retail bank provides an exchange for derivatives of European securities. It is an over-the-counter (OTC) request-for-quote and execution system (but provides no settlement and clearing services). A broker submits a request for a quotation and includes the investment identifier and quantity. The system accepts the quotation and applies certain business rules. Depending upon the investment identifier and market conditions, the request is routed to a particular third-party market-maker who then calculates and provides the bid and ask price for the derivative. The response is returned to the broker via the OTC exchange. The broker can then execute the trade of the derivative through a subsequent request, which is routed via the OTC exchange to the appropriate market maker.

The complication with this arrangement is that arbitrage traders can take advantage of the latency delay in the bank’s OTC exchange infrastructure because the arbitrage trader can measure the latency that occurs during the small period in which the request for quotation is handled. In a fast moving market, price changes of the derivative may occur within this latency period. This presents an opportunity for an arbitrage trader to take advantage of inefficiency in the marketplace and expose the investment bank to intolerable risk.

The investment bank requires a very high performance-driven software infrastructure, such as JRockit Real Time. It requires that the latency of the OTC exchange be extremely low. Specifically, to combat arbitrage traders, the latency of the exchange’s infrastructure must be less than the latency of the arbitrage traders’ infrastructure. In this way, the arbitrage traders’ data becomes stale before the exchange’s, and therefore is not actionable.

Competition-Beating Risk Calculation Infrastructure

A large investment bank is a market-maker for fixed income securities. A request-for-quote (RFQ) is received from an inter-dealer market electronic communication network (ECN), such as TradeWeb. This RFQ would have been submitted to a number of entities. To be competitive, it is vital that the quotation is returned as quickly as possible with the best possible price. Therefore, a minimum amount of latency is necessary to ensure that the investment bank wins customers, or at least, the latency is less than that of the organization’s competitors.

During the quotation process, a risk and pricing model is executed to determine the quote price to provide to the customer. Because of the complexity of these calculations, they are currently performed overnight. The result is a stratum of at least four grades of risk advisories that govern fixed rate securities prices. Note that there is at least a twelve-hour lag in these risk calculations. This leads to a risk window since the calculations are stale even at the start of next-day business. To lower this risk, and potentially provide better rates to customers, a real-time risk and pricing calculator would be required. JRockit Real Time provides a latency-adverse infrastructure to make this feasible.

Oracle JRockit JDK 6 R27.6

The Oracle JRockit JDK 6 R27.6 is certified to be compatible with Java SE 6 (update 3). This version includes the Deterministic Garbage Collector for dynamic garbage collection priority that ensures extremely short pause times and limits the total number of those pauses within a prescribed window, as described in Deterministic Garbage Collection. It also installs the JRockit Runtime Analyzer (JRA), Latency Analysis Tool (LAT), and Memory Leak Detector, which provide internal metrics that are useful for profiling the Oracle JRockit JVM, as described in JRockit Runtime Analyzer (JRA).

Oracle JRockit JDK 5.0 R27.6

The Oracle JRockit JDK 5.0 R27.6 is certified to be compatible with J2SE 5.0 (update 14). The 5.0 R27.3 JVM includes the Deterministic Garbage Collector for dynamic garbage collection priority that ensures extremely short pause times and limits the total number of those pauses within a prescribed window, as described in Deterministic Garbage Collection. It also installs the JRockit Runtime Analyzer (JRA), Latency Analysis Tool (LAT), and Memory Leak Detector, which provide internal metrics that are useful for profiling the JRockit JVM, as described in JRockit Runtime Analyzer (JRA).

Oracle JRockit JDK 1.4.2 R27.6

The Oracle JRockit JDK 1.4.2 R27.6 is certified to be compatible with J2SE 1.4.2_16. The 1.4.2 R27.6 JVM includes the Deterministic Garbage Collector for dynamic garbage collection priority that ensures extremely short pause times and limits the total number of those pauses within a prescribed window, as described in Deterministic Garbage Collection. It also installs the JRockit Runtime Analyzer (JRA), which provides internal metrics for Java developers using the JRockit JVM as their runtime JVM, as described in JRockit Runtime Analyzer (JRA).

Deterministic Garbage Collection

Memory management relies on effective garbage collection, which is the process of clearing dead objects from the heap, thus releasing that space for new objects. JRockit Real Time uses a dynamic “deterministic” garbage collection priority (-Xgcprio:deterministic) that is optimized to ensure extremely short pause times and limit the total number of those pauses within a prescribed window.

For certain types of applications, particularly in the Telecom and Finance industries, stringent requirements are placed on transaction latency. When these applications are written in Java, the unpredictable pause times caused by garbage collection can have a profound and potentially harmful affect on this latency.

However, shorter deterministic pause times do not necessarily equal higher throughput. Instead the goal of the deterministic garbage collection is to lower the maximum latency for applications that are running when garbage collection occurs. Such shorter pause times should lessen the impact of the deterministic garbage collection compared to running a normal garbage collection.

For more information on the deterministic garbage collector, see the Oracle JRockit
Diagnostics Guide.

Enabling the Deterministic Garbage Collector

For standalone or Spring-Based Java applications, enable the Deterministic Garbage Collector by doing one of the following:

Enter the -Xgcprio:deterministic option from a Java command line.

Use the sample startup scripts, startRealTime (.cmd/.sh), that demonstrate how to start the Oracle JRockit JVM with deterministic garbage collection enabled.

JRockit Runtime Analyzer (JRA)

The JRockit Runtime Analyzer (JRA) is an application that helps you profile your application and the Java runtime. It provides a wealth of useful metrics that are useful when using the JRockit JVM as your runtime VM.

The JRockit Runtime Analyzer consists of two parts. One part runs inside the JVM and records information about the currently running JVM and the Java application and saves this information to a JRA recording file (filename.jra). This file is opened in the other part of the tool, the analyzer, which is a regular Java application used to visualize the information in the file.

The JRocking Runtime Analyzer is packaged as part of the JRockit Mission Control 3.1.0 tool suite. Documentation for Mission Control 3.1.0 is bundled with the tools as online documentation. For general information about Mission Control 3.1.0, see
Introduction to Oracle JRockit Mission Control.

Supported Configurations for JRockit Real Time

Oracle JRockit Real Time is supported on the same configurations (hardware and platform) as Oracle JRockit JVM R27.6, with the exception of Windows Itanium and Linux Itanium configurations: it is not supported on those configurations. For a complete list of supported configurations, please refer to Oracle JRockit
Supported Configurations.

Terminology

A level of computer responsiveness that a user senses as sufficiently immediate or that enables the computer to keep up with some external process (for example, to present visualizations of the weather as it constantly changes).

Latency

An expression of how much time it takes for data to get from one designated point to another.

Throughput

The amount of work that a computer can do in a given time period.

Deterministic garbage collection

Short, predictable pause times for memory heap garbage collection, which is the process of clearing dead objects from the heap, thus releasing that space for new objects.