The WebLogic Real Time server (WLRT) provides a lightweight infrastructure with low latency for event-driven applications. It is intended for use in highly competitive environments where performance is key and therefore every millisecond counts. For example, certain industries such as telecommunication or insurance require that transactions be performed with very low latency within given timeframes. Trying to implement this with standard Java most likely will fail because of the unpredictable pause times caused by the garbage collection process. This is where WLRT comes in. In conjunction with the JRockit JVM, which introduces a deterministic garbage collection, the JRockit JVM provides a J2EE runtime for performing these critical applications. The deterministic garbage collection ensures that the pause times during program execution are extremely short and pending requests are processed within a defined timeframe—enabling you to build high performance and deterministic applications.
To understand the new product we need to take a closer look at the entire bundle. WLRT is a WebLogic Server that banks on the new features from the JRockit JVM and that enables lightweight programming with the integrated BEA Spring Framework:
Let's look at each of these in more detail.
WebLogic Server 9.1 is the latest release of the well known and established enterprise Java application server from BEA. In addition to the complete implementation of the J2EE 1.4 specification it provides a standard set of APIs for creating distributed Java applications that can access a wide variety of services, such as databases, messaging services, and other connections to external enterprise systems. With WebLogic Server enterprises can deploy mission-critical applications in a robust, secure, highly available, and scalable environment. All this can be implemented in given infrastructures using a wide set of clustering, administration, and monitoring features. As part of the WLRT, WebLogic Server is the service provider for the event-driven, low-latency applications.
Garbage collection has a big impact on Java performance. During a full garbage collection run, Java processes come to a complete stop. Processing continues once garbage collection is finished. The process of clearing dead objects from the heap and releasing that space for new ones needs to be highly optimized in order to guarantee effective memory management.
JRockit can use a dynamic "deterministic" garbage collection priority (
-Xgcprio:deterministic). This strategy is optimized to ensure extremely short pause times and limit the total number of those pauses within a well defined timeframe (this is also called a "sliding window"). This is useful for certain applications where stringent requirements are placed on transaction latency. However, even the shorter deterministic pause times do not necessarily guarantee a higher application throughput. The goal of the deterministic garbage collection is to lower the latency for applications that are running while garbage collection occurs. Compared with the impact of a normal garbage collection this leads to much shorter pause times. With the introduction of the deterministic garbage collection priority within JRockit 5.0 R26, the following guarantees for transaction latency can be made:
These targets can be met for applications with 1 GB heap and an average of 30 percent or less live data at collection time. The WLRT documentation states that this has been verified on the following hardware:
Running on slower hardware with a different heap size and/or with more live data may break the deterministic behavior. In these cases, you may need to increase the pause time target by using the
-XpauseTarget option. The deterministic garbage collection is only available as part of WLRT. If you try to enable it without the proper license file you will get a nice warning written to the server console.
The final part of WLRT is the Spring Framework 1.2.6 for BEA WebLogic Real Time. As a lightweight application development framework it greatly simplifies the development effort compared to traditional J2EE development. It has proven itself to be very flexible, easy to use, and capable of working in highly latency-sensitive environments. With the use of Plain Old Java Objects (POJOs) as alternatives to EJBs, the Spring Framework is still able to access all reliability features of WebLogic Server. In addition, it enforces modular and reusable coding practices. It also includes JavaBeans-based configuration, an AOP framework, declarative transaction management, JDBC support, and a web MVC framework. It is certified on WebLogic Server (from release 9.0). You can download the BEA supported version of Spring from the WebLogic Real Time Product download page. For more information on the framework and its integration with WebLogic Server, read Spring Integration with WebLogic Server (Dev2Dev, September 2005).
After having read all about the individual components that make up the WLRT the only thing left is to put everything together. Figure 1 shows how all the components are expected to work together. The essential building block is the JRockit JVM with the new deterministic garbage collection. In contrast to other JVMs, it guarantees extremely short garbage collection runs. You will only get this result if you build the application on top of a high-performance container. For WLRT 1.0, this is WebLogic Server 9. But at the end of the day the key to a high-performance and reliable application is your own code. The WLRT respects this by integrating the well known Spring Framework as an architectural component, but you are not obliged to use it. Nevertheless, it is a good start for building modular, reusable, and performing applications. If you use it to develop your application it is much easier to stick to common and well known patterns for optimized resource access and other things critical in sensitive environments.
Figure 1. Architecture of the WebLogic Real Time server