Description
WebSphere Real Time V3.0 is a Java Runtime Environment and Software Development Kit designed to provide more consistent performance for Java applications, enabling customers to develop applications with low latency and highly predictable response times. Commercial Java Runtime Environments (JRE) are not able to deliver this predictable, or real-time behavior because of the unpredictability of application execution time. Two areas that can give rise to such unpredictability are:
Garbage collection (GC), where the Java Virtual Machine (JVM) unpredictability interrupts the application execution to manage memory, freeing portions of Java-managed memory that are of no further use to an application for use by other applications.
Just-in-time (JIT) compiler, which will improve the performance of Java applications when compared to the traditional interpreted mode by compiling sections of code that are in frequent use. While JIT compilation dramatically improves application performance, it also gives rise to unpredictability of application execution time because early runs of the application can be interrupted to allow the compiler to execute.
WebSphere Real Time V3.0 can be used in servers or other Java applications with “soft” real-time goals such as consistent performance and service quality on Linux and IBM AIX systems.
WebSphere Real Time V3.0 can also be used to build “hard” real-time systems with aggressive and stringent timing constraints using the Java language running on real-time Linux , with lower development costs than using more traditional real-time system languages like ADA, C, and C++.
What's new
| WebSphere Real Time v3.0 | WebSphere Real Time v2.0 |
|---|---|
| Support for Java Standard Edition (JSE 7.0) | Support for Java Standard Edition (JSE 6.0) |
| Platform support for standard Linux, IBM AIX, Real-time Linux distributions | Platform support for standard Linux, IBM AIX (v2 SR3), and Real-time Linux distributions |
| Configurable Garbage Collection pause times as short as 1ms (default 3ms) | Less than 3ms Garbage Collection pause times |
| Compressed and non-compressed 64-bit support | Compressed references for 64-bit |
| No limit for heap size | Heap size < 28MB |
| Improved throughput performance on server workload | Performance baseline |
The key advantage to WebSphere Real Time is that it is designed to reduce or eliminate the primary source of unpredictable application pauses via its “Metronome” Garbage Collection technology while preserving the benefits of using the Java language.
When using WebSphere Real Time, typical applications can expect average garbage collection pauses less than 1ms on Red Hat MRG / Novell SLERT real-time operating systems and configurable pause time target (1ms and up) on other supported operating systems, defaulting to under 3ms. By preserving the garbage collection model, memory management remains transparent to developers, unlike an alternative approach called "scoped memory." Scoped memory can be extremely difficult to use, introducing complexities in programming and forcing developers to determine their memory requirements prior to runtime. Further, by utilizing existing Java class libraries, WebSphere Real Time retains the productivity and reusability aspects that make Java so attractive.
WebSphere Real Time reduces the problem with class loading through the use of the shared class cache to store classes in an internal format close to that used by its virtual machine at runtime. Ahead-of-time (AOT) and just-in-time (JIT) compilation can be further used to optimize the execution environment. In particular, AOT code can be stored into a shared class cache before program runtime and can be loaded into the virtual machine as classes are loaded, to provide the highest level of deterministic performance. The JIT compiler runs asynchronously on a low-priority thread so that it can dynamically improve the performance of an application while giving system designers a simple way to prevent the compiler from interfering with higher-priority application tasks.
For applications that require even lower latency than provided by the real-time garbage collection, WebSphere Real Time supports the Real Time specification for Java (RTSJ). Programmers can use the many standard features, including priority-based thread scheduling, high-resolution timers, and asynchronous event handlers.
The RTSJ, also known as Java Specification Request 1 (JSR-1), extends the Java language to support real-time behavior. It defines a number of language constructs similar to the traditional real-time programming languages. In doing so, it extends the Java programming model by allowing the application programmer to control memory areas ("Scoped Memory"), thread scheduling, and asynchronous event handling. While features such as scoped memory are incredibly powerful, and are required for applications that require sub-millisecond worst-case delays, they require much more significant programming skills, in particular for managing memory. WebSphere Real Time enables customers to write the majority of their application using standard Java, dipping into the powerful constructs in RTSJ as required. For many applications, features such as scoped memory will not be required, but the other features of RTSJ are fully available.
WebSphere Real Time is comprised of the following components:
Real-time garbage collection
Shared Classes support
Full support for Java Standard Edition (JSE 7.0)
Full support for JCP Real-time Specification for Java 1.0.2
A well-defined list of JDK classes that are No-Heap Real-Time Thread (NHRT) safe
Support for SMP multiprocessor x86 Linux platforms (including IBM BladeCenter)
WebSphere Real Time is supported on IBM hardware that has firmware compatible with real-time requirements. The firmware has been designed to eliminate system management events that may interrupt the processing of real-time applications and result in nondeterministic behavior.
A core feature of the real-time environment is the underlying open source real-time operating system. WebSphere Real Time supports an enhanced Linux kernel using system libraries and binaries available from Red Hat and Novell. IBM worked with the Linux community to develop the real-time operating system capabilities needed to obtain required performance for WebSphere Real Time and has subsequently made them available via the open source community.
Section 508 of the U.S. Rehabilitation Act
WebSphere Real Time satisfies the applicable requirements of Section 508 of the Rehabilitation Act, provided that any assistive technology used with the product properly interoperates with it. A U.S. Section 508 Voluntary Product Accessibility Template (VPAT), containing details on the products accessibility compliance, can be requested at http://www.ibm.com/able/product_accessibility/index.html
IPLA and Subscription and Support considerations
IPLA licenses can be transferred from one machine to another within, but not limited to an enterprise. You may aggregate the capacity for all the processors the product is operated on to achieve a more economic price. This will result in a single Proof of Entitlement (PoE). It is your responsibility to manage the distribution of Value Units within the limits of the entitlement of the product license.
Subscription and Support must cover the same capacity as the product license entitlement. Subscription and Support will be available in the country in which the agreement is made.
