#
IBM(R) zSeries Runtime Environment for Linux, Java(TM) 2 Technology Edition
- README -

Note: Before using this information and the product it supports, be sure to read the general information under Notices.

This edition of the README applies to the IBM zSeries Runtime Environment for Linux, Java 2 Technology Edition, and to all subsequent releases and modifications until otherwise indicated in new editions.

(c) Copyright IBM Corporation 1999, 2002. All rights reserved.

(c) Copyright Sun Microsystems, Inc. 1997, 2001. 901 San Antonio Rd., Palo Alto, CA 94303 USA. All rights reserved.

U.S. Government Users Restricted Rights -- Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

This README file provides information about the Runtime Environment for Linux package provided with the IBM(R) zSeries Developer Kit for Linux, Java(TM) 2 Technology Edition, (Developer Kit for Linux) at the Sun SDK 1.3.1 Level.

The Runtime Environment allows you only to run Java applications. If you want to write and then run Java applications, you must install the Developer Kit for Linux. If you have installed the Developer Kit for Linux, you do not need the Runtime Environment, which is a subset of the Developer Kit.

For the list of distributions against which the Developer Kit for Linux has been tested, see:
http://www-106.ibm.com/developerworks/java/jdk/linux/tested.html

## Contents

- Overview
- Files included with the Runtime Environment for Linux
- License agreement
- The just-in-time (JIT) compiler
- The Native Method Interface and the Java Native Interface
- Configuring the Runtime Environment for Linux
- Installing additional fonts
- Installing on Red Hat
- Installing on SuSE
- Installing if using BEA Weblogic
- Uninstalling the Runtime Environment for Linux
- Uninstalling the RPM package
- Uninstalling the compressed TAR package
- Invoking the Java Runtime Interpreter
- System properties
- Obtaining the IBM build and version number
- Working with floating stacks
- Switching the input method in DBCS languages
- Devanagari fonts
- Runtime example
- Installing your application on a user's system
- Specifying garbage collection policy
  - Pause time
  - Pause time reduction
  - Environments with very full heaps
  - Further information about garbage collection
- Runtime Environment for Linux documentation
- Known limitations
- General information
- Information about Linux memory allocation
- Information for Japanese users
- Notices
- Trademarks

## Overview

The Runtime Environment for Linux contains the subset of classes required to create a Java runtime environment and to run Java programs. It also contains the Java Virtual Machine, Java classes, and supporting files. The Runtime Environment for Linux contains only a subset of the classes found in the Java Developer Kit.

### Files included with the Runtime Environment for Linux

The Runtime Environment for Linux includes non-debuggable .so files and class files needed to support a program at runtime. The Runtime Environment for Linux does not include any of the development tools, such as appletviewer or javac, or classes that would pertain only to a development system.

In addition, the Java Authentication and Authorization Service (JAAS) package is provided for use with the Runtime Environment for Linux.

### License agreement

The LICENSE_xx.html file contains the license agreement for the Runtime Environment for Linux software. (xx is the locale abbreviation.)

To view or print the license agreement, open the file in a Web browser.

### The just-in-time (JIT) compiler

The just-in-time (JIT) compiler (libjitc.so) dynamically generates machine code for frequently used bytecode sequences in a Java application or applet while it is running.

The Runtime Environment for Linux includes the JIT compiler (libjitc.so), which is enabled by default. You can disable the JIT to help isolate a problem with a Java application, an applet, or the compiler itself. To disable the JIT, at a shell prompt type:

        export JAVA_COMPILER=NONE

To enable the JIT, type at a shell prompt:

        unset JAVA_COMPILER

To verify whether or not the JIT is enabled, type at a shell prompt:

        java -version

If the JIT is in use, a message is displayed that includes:

        JIT enabled: jitc

If the JIT is not in use, this message is displayed:

        JIT disabled

### The Native Method Interface and the Java Native Interface

IBM does not support the Native Method Interface in this release. Do not use this interface in your applications.

The Java Native Interface (JNI) is included with the Runtime Environment. For information about using the JNI, see the Sun Web site:

  http://java.sun.com

1. Select Products & APIs.
2. Select Java 2 Platform, Standard Edition (J2SE) under Product Groups.
3. Select Java 2 SDK, Standard Edition, v 1.3.1 under Current Releases.
4. Select browse documentation online under J2SE 1.3.1 Documentation.
5. Select Java Native Interface (JNI) under Guide to Features - Java Platform.

## Configuring the Runtime Environment for Linux

After you install the Runtime Environment for Linux, edit your shell script and add this directory to your PATH statement:

  /opt/IBMJava2-ppc-131/jre/bin

If you installed the Runtime Environment for Linux in a directory other than /opt/IBMJava2-ppc-131, replace /opt/IBMJava2-ppc-131 with the directory in which you installed the Runtime Environment for Linux.

### Installing additional fonts

Java is able to display all Unicode characters, but most versions of Linux install only the fonts needed to show your language. You can download fonts from IBM that enable you to see the complete Unicode character set. These fonts are not included in the Developer Kit for Linux package because they are large and not all users need them. IBM supplies two Unicode fonts, and each of them is customized by country. Users in China and Korea must use the country specific versions, and all others must use the Japanese version of these fonts.

You can download fonts from the developerWorks Web site at http://www.ibm.com/developer/java/. Descriptions of the fonts are provided to help you decide which fonts to download.

To install a font, put the file in the /opt/IBMJava2-ppc-131/jre/lib/fonts directory.

If you download fonts in parts, you must combine the parts together into one file for each font. To do this, be sure the parts are in the /opt/IBMJava2-ppc-131/jre/lib/fonts directory and use the cat command.

For example, if you downloaded the Times New Roman WT J font in parts, type the following command to put it back together:

        cat tnrwt_j.t01 tnrwt_j.t02 tnrwt_j.t02 >  tnrwt_j.ttf

### Installing on Red Hat

When you are installing on a Red Hat system, to allow the font server to find the Java TrueType fonts, run:

    su root
    /usr/sbin/chkfontpath --add /opt/IBMJava2-131/jre/lib/fonts

You must do this at install time and you must be `root` to run the command.

### Installing on SuSE

If you are running a SuSE system, there may be a version of this Runtime Environment already installed. If this version was supplied by SuSE, it will have been packaged so that it installs under a different directory tree. To avoid unexpected results, you should use YaST2 to remove the SuSE-supplied Runtime Environment .

### Installing if using BEA Weblogic

If you intend to use the BEA Weblogic server, when you install the Developer Kit for Linux packages you must unselect the JAAS optional installation. The BEA Weblogic server contains its own implementation of JAAS.

## Uninstalling the Runtime Environment for Linux

The process you use to remove the Runtime Environment for Linux depends on whether you installed the RPM package or the compressed TAR package. See Uninstalling the RPM package or Uninstalling the compressed TAR package for instructions.

### Uninstalling the RPM package

To uninstall the Runtime Environment for Linux if you installed the RPM package:

1. At a prompt, type:

           rpm -qa | grep IBM

   The name of the package is displayed.

2. Use the rpm command:

           rpm -e IBMJava2-JRE

3. Remove from your PATH statement the directory where you installed the Runtime Environment.

### Uninstalling the compressed TAR package

To uninstall the Runtime Environment for Linux if you installed the compressed TAR package:

1. Remove the Runtime Environment files from the directory where you installed the Runtime Environment.

2. Remove from your PATH statement the directory where you installed the Runtime Environment.

## Invoking the Java Runtime Interpreter

The Runtime Environment for Linux can be invoked from a shell prompt by using the java tool.

- To execute a class:

          java [-options] classname <args>

  The `classname` argument is the name of the class file to be executed. Any arguments to be passed to the class must be placed after the `classname` on the command line.

- To execute a jar file:

          java -jar [-options] jarfile <args>

  The `jarfile` argument is the name of the jar file to be executed. Any arguments to be passed to the jar file must be placed after the `jarfile` on the command line.

Options for the java tool are as follows:

-D<name>=<value>
  Sets a system property.
-cp or -classpath <directories and zip or jar files separated by ;>
  Sets search path for application classes and resources.
-help or -?
  Prints a usage message.
-showversion
  Prints product version and continues.
-verbose[:class | gc | jni]
  Enables verbose output.
-version
  Prints product version.
-X
  Prints help on nonstandard options.
-Xbootclasspath:<directories and zip or jar files separated by ;>
  Sets search path for bootstrap classes and resources.
-Xbootclasspath/a:<directories and zip or jar files separated by ;>
  Appends to end of bootstrap class path.
-Xbootclasspath/p:<directories and zip or jar files separated by ;>
  Prepends in front of bootstrap class path.
-Xcheck:jni
  Performs additional checks for JNI functions.
-Xcheck:nabounds
  Performs additional checks for JNI array operations.
-Xdebug
  Enables remote debugging.
-Xfuture
  Enables strictest checks, anticipating future default.
-Xgcpolicy:{optthruput | optavgpause}
  Specifies the garbage collection setting. For more information, see Specifying garbage collection policy.
-Xgcthreads:<n>
  Specifies the number of threads to be used for garbage collection.
-Xms<size>
  Sets initial Java heap size.
-Xmx<size>
  Sets maximum Java heap size.
-Xnoagent
  Disables support for oldjdb debugger.
-Xnoclassgc
  Disables class garbage collection.
-Xoss<size>
  Sets maximum Java stack size for any thread.
-Xquickstart
  Used for improving startup time of some Java applications. -Xquickstart causes the JIT to run with a subset of optimizations - a quick compile. This quick compile allows for improved startup time. -Xquickstart is appropriate for shorter running applications, especially those where execution time is not concentrated in a small number of methods. -Xquickstart can degrade performance if used on longer running applications containing hot methods. The implementation of -Xquickstart is subject to change in future releases.
-Xrs
  Reduces the use of operating system signals.
-Xrunhprof[:help] | [:<option>=<value>, ...]
  Performs heap, CPU, or monitor profiling.
-Xrunjdwp[:help] | [:<option>=<value>, ...]
  Loads debugging libraries to support remote debug applications.
-Xss<size>
  Sets maximum native stack size for any thread. For more information, see Working with floating stacks

The -X options are nonstandard and subject to change without notice.

## System properties

The system property ibm.jvm.bootclasspath can be set using the -D option described in Invoking the Java Runtime Interpreter. The value of this property is used as an additional search path, inserted between any value defined by -Xbootclasspath/p: and the bootclass path. The bootclass path is either the default, or that defined using the -Xbootclasspath: option.

## Obtaining the IBM build and version number

To obtain the IBM build and version number, at a shell prompt type :

`java -version`

## Working with floating stacks

On a non-floating stack Linux system, regardless of what is set for -Xss, a minimum native stack size of 256KB for each thread is provided. On a floating stack Linux system, the -Xss values are honored. Thus, if you are migrating from a non-floating stack Linux system, you must ensure that any -Xss values are large enough and are not relying on a minimum of 256KB.

## Switching the input method in DBCS languages

On double-byte character set (DBCS) systems, if you want to switch the input method, you must set an environment variable that represents the keycode you use for switching. Optionally, you can set another environment variable that represents the modifiers of the keycode.

To specify the keycode to use for switching, set the IBMJAVA_INPUTMETHOD_SWITCHKEY environment variable to a keycode definition in the java.awt.event.KeyEvent class, for example, VK_F4.

Optionally, specify modifiers of the keycode. To specify modifiers of the keycode, set the IBMJAVA_INPUTMETHOD_SWITCHKEY_MODIFIERS environment variable to some combination of the following three mask definitions in the java.awt.event.InputEvent class:

- ALT_MASK
- CTRL_MASK
- SHIFT_MASK

Separate the masks by commas.

For example you might set the IBMJAVA_INPUTMETHOD_SWITCHKEY_MODIFIERS environment variable to ALT_MASK, CTRL_MASK.

During Java initialization, the two environment variables are stored.

To be sure you have set the environment variables correctly, press a key and check it with the key combination you specified. If it matches, a Java pop-up menu with selectable input methods is displayed.

## Devanagari fonts

This Developer Kit does not ship Devanagari fonts (Devamt.ttf and Devamtb.ttf) in the jre/lib/fonts directory. Instead, where appropriate, Java uses the Monotype Unicode fonts (Times New Roman WorldType and Sans Monospace WorldType) shipped with the IBM platform or IBM software product to support Devanagari (Hindi) fonts.

## Runtime example

The following Sun Web page might contain a "Hello World" example that you can download. The example demonstrates how to create a simple Java application that runs on and is bundled with the Runtime Environment for Linux. You might find the example at the Sun Web site:

  http://java.sun.com

1. Select Products & APIs.
2. Select Java 2 Platform, Standard Edition (J2SE) under Product Groups.
3. Select Java Runtime Environment, Standard Edition, v 1.3.1 under Current Releases.
4. Select Browse under Documentation on the left.
5. Select Notes for Developers under Java Runtime Environment and Java Plug-in.

The example shows how to make a simple, seamless transition from developing an application with the Developer Kit for Linux, to deploying it with the more lightweight Runtime Environment for Linux.

## Installing your application on a user's system

After you develop your product and are ready to ship, you need to install your product on a user's system, configure the user's system to support your software, and configure the runtime environment.

If you use the Runtime Environment for Linux, you must make sure that your installation procedure does not overwrite an existing installation (unless the existing Runtime Environment for Linux is an older version).

To redistribute the Runtime Environment for Linux, you can install it on your own system, then copy the required Runtime Environment files into your installation set. If you choose this approach, you must include all the files provided with the Runtime Environment for Linux. The Runtime Environment for Linux software can only be redistributed if all files are included. In effect, when you ship your application, it has its own copy of the Runtime Environment for Linux.

For specific information about the files that must be redistributed, see the license agreement that accompanies this product.

## Specifying garbage collection policy

The IBM Runtime Environment for Linux, Java 2 Technology Edition, V1.3.1 introduces the -Xgcpolicy JVM runtime option for specifying garbage collection policy.

-Xgcpolicy takes two values, optthruput (the default) and optavgpause. The option controls garbage collector behavior, making tradeoffs between throughput of the application and overall system and the pause times caused by garbage collection.

The format of the option and its values is:

> -Xgcpolicy:optthruput

and

> -Xgcpolicy:optavgpause

### Pause time

When an application's attempt to create an object cannot be satisfied immediately from the available space in the heap, the garbage collector is responsible for identifying unreferenced objects (garbage), deleting them, and returning the heap to a state in which the immediate and subsequent allocation requests can be satisfied quickly. Such garbage collection cycles introduce occasional unexpected pauses in the execution of application code. As applications grow in size and complexity, and heaps become correspondingly larger, this garbage collection pause time tends to grow in size and significance. The default garbage collection value, optthruput, delivers very high throughput to applications, but at the cost of these occasional pauses, which can vary from a few milliseconds to many seconds, depending on the size of the heap and the quantity of garbage.

### Pause time reduction

The optavgpause value substantially reduces the time spent in these garbage collection pauses, as well as limiting the effect of increasing heap size on the length of the garbage collection pause. This is particularly relevant to configurations with large heaps. (Consider a heap as large when it is at least 1 GB.) The pause times are reduced by overlapping garbage collection activities with normal program execution. This overlapping results in a small reduction to application throughput.

### Environments with very full heaps

If the Java heap becomes nearly full, and there is very little garbage to be reclaimed, requests for new objects might not be satisfied quickly because there is no space immediately available. If the heap is operated at near-full capacity, application performance might suffer regardless of which of the above options is used; and, if requests for more heap space continue to be made, the application receives an Out of Memory exception, which results in JVM termination if the exception is not caught and handled. In these situations, you are recommended either to increase the heap size using the -Xmx option or to reduce the number of application objects in use.

### Further information about garbage collection

For information on heap size tuning and the implications of garbage collection for application performance, see:

http://www.ibm.com/developerworks/library/j-jtc/index.html

http://www.ibm.com/developerworks/library/j-tip-heap-size.html

http://www.ibm.com/developerworks/library/j-leaks/index.html

## Runtime Environment for Linux documentation

IBM supplies the following runtime documentation:

- Each property file contains comments that describe what the file is useful for and how to modify it.

- KeyEvent uses the awt.properties file to print properties of key events, usually for debugging purposes.

## Known limitations

### General information

- If you use the Java FontMetrics class to calculate the width of a font to use the draw method, it returns the wrong answer, and the text does not display properly. This problem occurs because the numbers used in the calculation come from the Java2D, and the calculations are performed in the Abstract Widows Toolkit (AWT). The workaround for this problem is to get the numbers from and perform the calculations in the AWT. You can do this by setting the JAVA2D_USEAWTFONTS system variable to zero before starting the Developer Kit for Linux.

- If you use audio on a machine without a soundcard, you may get an error message stating that you are out of memory when Java tries to play a sound. The message is displayed in the console, but it does not affect your Java application.

- You might not be able to use the system clipboard to copy information between Linux applications and Java applications if you are running K Desktop Environment (KDE) as your window manager.

  1. In the list on the left, select Site Map.
  2. Under Server Support, select Linux.

- If a Java application is terminated with a Ctrl-C by the user, a number of processes might be left orphaned.

- The javap program, when run on an interface, duplicates the string "interface" in the result. For example, running javap on "java.lang.Runnable" produces:

           public interface interface java.lang.Runnable extends java.lang.Object...

- Displaying dialog boxes created with Swing might cause a delay of a few seconds before they are displayed in the window.

- KeyEvent results involving the ALT key differ when using different window managers in Linux. They also differ from results in other operating systems. In the Enlightenment window manager, Alt+A and Shift+Alt+A produce different modifiers, and Ctrl+Alt+A produces no key event at all. However, using the WindowMaker window manager, Ctrl+Alt+A produces a key event.

  On the Linux X Window System, the keymap is set to: 64 0xffe9 (Alt_L) 0xffe7 (Meta_L), and 113 0xffea (Alt_R) 0xffe8 (Meta_R). You can check this by typing the following at a shell prompt:

               xmodmap -pk

### Information about Linux memory allocation

Java applications that use many threads can exceed the systems memory capacity. Use the following formula to estimate the maximum number of threads a Java application can use:

        heap_size(MB) + 2*thread_count <      910   (approximately)

When memory is exhausted, the JVM or the JIT will report an error condition similar to one of the following:

       Exception in thread "main"
          java.lang.OutOfMemoryError
          at java.lang.Thread.start(Native Method)
          at serling.main(serling.java:29)

       COMPILER ERROR: java/io/ObjectStreamClass.compareClassNames - JIT:
          Out of memory, emitcode

It is the "out of memory" indication that is significant, not the specific files or methods that are named. It is also possible that other error messages may follow the above which do not indicate additional errors, but instead indicate secondary effects of the out of memory condition.

### Information for Japanese users

This release supports only US English and Japanese. Japanese language support was tested only with TurboLinux Server 6.1 for zSeries and S/390, and not tested with SuSE Linux 7.0. This was because, at present, only TurboLinux Server 6.1 for zSeries and S/390 supports Japanese.

#### Japanese fonts

Swing components can display Japanese fonts by installing the Japanese WorldType fonts. (See the section on Installing additional fonts). Installing Japanese WorldType fonts does not affect AWT components nor IM switching panels. To avoid this problem, additional Japanese TrueType fonts need to be installed.

TurboLinux Japan have made the Japanese TrueType fonts available from their website - http://www.turbolinux.co.jp (Search word : truetype)

#### Tested environments

S/390 does not have any natively attached graphical displays. Therefore a remote system, which has a graphical display, is required. There are two ways to display X applications on the remote systems.

1. XDMCP (X Display Manager Control Protocol): The Graphic Client displays the entire X screen of the Linux S/390 system.
2. DISPLAY contents: The Graphic Client displays the application window of the Linux S/390 system.

TurboLinux Server 6.1 for zSeries and S/390 does not have any IM (Input Method) interface such as kinput2. As a result only the second option above has been tested for this release.

The following environments have been tested :

System | OS | Language | Window Manager | Host Attached Input Method Engine
Java System | TurboLinux for S/390 | Japanese (EUC) | FVWM2 lesstif-mwm, twm (no kinput2) | Canna 3.5 (no kinput2)
Graphic Client | TurboLinux Server J6.5 | Japanese (EUC) | Sawfish1 with GNOME | Canna 3.5 with kinput2 FreeWnn with kinput2

#### Japanese Kana-Kanji conversion users

On Japanese versions of Linux, you can use a Japanese input method such as Canna, ATOK12(TM) SE, Wnn4(TM), or Wnn6. Use the following sections to avoid problems when using these Japanese input methods.

All Input Method users

- If you use an IME on a TextArea or a TextField component, the committed text sometimes disappears when you commit the composed text. To avoid this problem, move the mouse pointer away from the composed text and away from the status information line when you commit the composed text. If you do encounter the problem, press the Enter key again, and then the committed text is displayed.

- If you use an IME on a TextArea or a TextField component, the composed text is sometimes displayed in the wrong position. To avoid this problem, do not change the component position vertically after you commit a string. If you do encounter this problem, re-activate the IME, and then the composed text is displayed at the correct position. The committed text is always displayed at the correct position.

- If you use an IME with the Sawfish (previously known as Sawmill) window manager, an Input Method Framework (IMF) status window, which is a small window attached to the Java client window, always stays on the top of all the windows on your desktop, even if you switch to another window.

  To bring another window to the top, do one of the following:

  - Minimize the Java client window
  - Drag the Java client window to move it away from the desktop.

Canna users
  If you are using the Canna input method with the kinput2 input method server, some visual feedback from the input method is not visible while you are in KIGOU input mode. To avoid the problem, move the focus onto the client window after the Auxiliary Control Window opens.

ATOK12 SE users

- If you are using ATOK12 SE for Linux, composed text might not be committed immediately after you select a candidate in the lookup window. If you continue to input a character, then the committed candidate is displayed.
- If you are using ATOK12 SE for Linux, changing the input focus between the components neither commits nor flushes the composed text, and you can continue to edit the composed text while other input methods commit or flush the composed text when the focus changes.

Wnn4 users
  If you are using Wnn4, the Enter key does not create a new line and a carriage return while the Input Method Editor (IME) is activated. To create a new line and carriage return, deactivate the IME.

Wnn6 users
  The xwnmo Input Method server is not supported. Use kinput2 as the Input Method server.

IIIMP IME users
  IME's (Input Method Editor) using Internet-Intranet Input Method Protocol(IIIMP) are not supported on TurboLinux Workstation 6.0J.

## Notices

This information was developed for products and services offered in the U.S.A.

IBM may not offer the products, services, or features discussed in this document in other countries. Consult your local IBM representative for information on the products and services currently available in your area. Any reference to an IBM product, program, or service is not intended to state or imply that only that IBM product, program, or service may be used. Any functionally equivalent product, program, or service that does not infringe any IBM intellectual property right may be used instead. However, it is the user's responsibility to evaluate and verify the operation of any non-IBM product, program, or service.

IBM may have patents or pending patent applications covering subject matter in this document. The furnishing of this document does not give you any license to these patents. You can send license inquiries, in writing, to:

- IBM Director of Licensing
  IBM Corporation
  North Castle Drive, Armonk
  NY 10504-1758 U.S.A.

For license inquiries regarding double-byte (DBCS) information, contact the IBM Intellectual Property Department in your country or send inquiries, in writing, to:

- IBM World Trade Asia Corporation Licensing
  2-31 Roppongi 3-chome, Minato-ku
  Tokyo 106-0032, Japan

The following paragraph does not apply to the United Kingdom or any other country where such provisions are inconsistent with local law:

INTERNATIONAL BUSINESS MACHINES CORPORATION PROVIDES THIS PUBLICATION "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Some states do not allow disclaimer of express or implied warranties in certain transactions, therefore, this statement may not apply to you.

This information could include technical inaccuracies or typographical errors. Changes are periodically made to the information herein; these changes will be incorporated in new editions of the information. IBM may make improvements and/or changes in the product(s) and/or the program(s) described in this information at any time without notice.

Any references in this information to non-IBM Web sites are provided for convenience only and do not in any manner serve as an endorsement of those Web sites. The materials at those Web sites are not part of the materials for this IBM product and use of those Web sites is at your own risk.

IBM may use or distribute any of the information you supply in any way it believes appropriate without incurring any obligation to you.

Licensees of this program who wish to have information about it for the purpose of enabling (i) the exchange of information between independently created programs and other programs (including this one) and (ii) the mutual use of the information which has been exchanged, should contact:

- JTCMAIL@uk.ibm.com
  [Hursley Java Technology Center (JTC) contact]

Such information may be available, subject to appropriate terms and conditions, including in some cases, payment of a fee.

The licensed program described in this document and all licensed material available for it are provided by IBM under terms of the IBM Customer Agreement, IBM International Program License Agreement or any equivalent agreement between us.

Any performance data contained herein was determined in a controlled environment. Therefore, the results obtained in other operating environments may vary significantly. Some measurements may have been made on development-level systems and there is no guarantee that these measurements will be the same on generally available systems. Furthermore, some measurement may have been estimated through extrapolation. Actual results may vary. Users of this document should verify the applicable data for their specific environment.

Information concerning non-IBM products was obtained from the suppliers of those products, their published announcements or other publicly available sources. IBM has not tested those products and cannot confirm the accuracy of performance, compatibility or any other claims related to non-IBM products. Questions on the capabilities of non-IBM products should be addressed to the suppliers of those products.

### Trademarks

IBM is a trademark of International Business Machines Corporation in the United States, or other countries, or both.

Java and all Java-based trademarks and logos are trademarks or registered trademarks of Sun Microsystems, Inc. in the United States, other countries, or both. The Java technology is owned and exclusively licensed by Sun Microsystems, Inc.

Other company, product, and service names may be trademarks or service marks of others.