HP-UX Java™ SDK Version 1.4.1.00 Release Notes


» Back to HP-UX Java™ Archived Releases – Release Notes

HP-UX SDK, for the Java™ 2 platform SDK version 1.4.1.00 with
HotSpot server 1.4.1.00 JVM

These Release Notes are provided in the software and as a standalone file on this website. The web version has the most up-to-date information regarding defect fixes.

The HP-UX SDK, for the Java 2 Platform Version 1.4 release provides the tools for developing and deploying Java applications on PA-RISC workstations and servers series with HP-UX 11.0 and 11i.

table of contents

features
» SDK Version 1.4.1.00 with Server HotSpot 1.4.1.00 JVM
» HotSpot 1.4.1 JVM

installation
» patches
» minimum system recommendation
» installation instructions
» Installing into an alternate location
» file structure

usage documentation
» supported tools and options
» additional HotSpot option information
» HP specific options and features
» new garbage collectors: parallel and concurrent mark and sweep
» large Java heap sizes

» using WDB to examine backtraces in Java thread stacks
» Asian TrueType fonts and Asian locales
» date/time methods - new defaults
» profiling capability added
» signal chaining functionality
» using JNI - main/primordial thread stack size limits
» using JNI - non-main/primordial thread stack size limits
» using JNI - dereferencing NULL pointers
» manually launching the application VM
» Closing a socket when accept or read is pending (PA-RISC & Itanium)
» C and C++ libraries
» JAR files
» compatibility with previous releases
» web sites with more information

problem fixes and known issues
» problem fixes
» known issues

features

SDK Version 1.4.1.00 with Server HotSpot 1.4.1.00 JVM  

The HP-UX SDK for the Java 2 Platform version 1.4.1.00 provides the tools for developing and deploying Java applications on HP systems with HP-UX 11.0 and 11i (11.11) PA-RISC.

HP's SDK 1.4.1.00 includes Sun Microsystems' 1.4.1_00 and 1.4.1_01 builds, defects fixed in our SDK 1.3.1 and previous 1.4 releases, as well as an additional enhancement described in the "Problems Fixed" section. Please note that on occasion HP backports a defect fix from a Sun release that has not yet been merged into our current sources. Therefore a Sun defect may be fixed in an HP release even though the Sun release that contains the fix is not part of the HP release.

The 1.4.1.00 SDK runs in 32-bit or 64-bit mode. It does not work with Itanium-based systems. Support for Itanium-based systems will be provided in our next 1.4.1 release.

The SDK 1.4.1.00 includes the HotSpot 1.4.1.00 server JVM; it does not include the Classic JVM.

Starting with this release, Java Web Start 1.2 is bundled with the SDK and RTE.

HotSpot 1.4.1 JVM  

The HotSpot 1.4.1 Server JVM for HP-UX 11.0 and 11i is suitable for both client and server workloads. We invoke the Server VM with configuration options that suit client-side applications.

All -X options that were in earlier HotSpot JVMs are included in HotSpot 1.4.1 Performance, tool support, tool enhancements, and features are documented at: http://java.sun.com/j2se/1.4.1/docs/.

The SDK 1.4.1 HotSpot 1.4.1 Edition supports the APIs core to the Java 2 platform: Java Foundation Classes (JFC), Security, Java IDL, JDBC™, JavaBeans™, Remote Method Invocation (RMI), Java 2D, and the Collections Framework, and a new set of nonblocking I/O APIs.

The Java 2 Platform version 1.4.1 API Specification is available at: http://java.sun.com/j2se/1.4.1/docs/api/.

NOTE: In this release, you will need to install a patch for /dev/poll runtime support. See the section "Known Problems" in these release notes for details.

The HotSpot 1.4.1 Server JVM provides:
  • Improved performance

  • Nonblocking I/O APIs

  • Full implementation of Java VM Debugging Interface (JVMDI)
    and Java Platform Debugger Architecture (JPDA)

  • Java VM Profiling Interface (JVMPI)

  • IPv6 support (Internet Protocol version 6)

  • Support for HP's debugger WDB 3.0.01 for Java stack unwind

  • -Xeprof option for HPjmeter

  • -Xrs option to reduce use of OS signals

  • 3GB heap size

  • 64-bit mode

  • Bundled Java Web Start

  • Support for Java 3D

  • Default, parallel scavenge, and concurrent mark sweep gc (see "default, parallel-scavenge, and concurrent mark sweep GC" under "known problems" in these release notes)

  • A new set of nonblocking I/O APIs are now part of the Java system libraries under the package java.nio. An improved I/O multiplexing mechanism based on /dev/poll has been integrated in the same nio framework. The previous implementation of I/O multiplexing using the class com.hp.io.Poll is still being included for backward compatibility. We encourage you to upgrade and use the features provided through the new java.nio package.

  • JVMDI: Full implementation of JVMDI and JPDA allows you to run HotSpot with numerous tools such as TogetherSoft Control Center, Code Warrior, Oracle JDeveloper, IBM Visual Age, Netbeans, JDE, MetaMata, Tek. Tools, Elixier IDE, BlueJ, JIG, JSwat Project, Swing Debugger, and the sample debugger jdb that ships with the SDK 1.4. For more information on JVMDI and JPDA, go to: http://java.sun.com/j2se/1.3/docs/guide/jpda/architecture.html

  • JPDA: Architecture and components are documented at: http://java.sun.com/products/jpda/ and http://java.sun.com/docs/index.html. The jdb for HP-UX is similar to the Solaris implementation. For usage information, see "Sun VM Invocation Options" at http://java.sun.com/products/jpda/doc/conninv.html.

  • JVMPI: Support for JVMPI means that you can profile java code with the HotSpot 1.4 VM. Therefore, you can extract more accurate runtime profiles. Some of the tools based on JVMPI include: hprof (-Xrunhprof), JProbe, JUM, and OptimizeIt.
    (Note: Although -hprof provides some stack trace information not found in -Xeprof, the latter can sometimes be more useful for performance tuning.)

  • IPv6 (Internet Protocol version 6) is a set of Internet Protocol specifications designed to provide enhancements over the capabilities of the existing IPv4 service in terms of scalability, security, mobility, ease-of-configuration, and real-time traffic handling.

    For more information, refer to Sun Microsystems' "Networking IPv6 User Guide for J2SDK/JRE 1.4" at http://java.sun.com/j2se/1.4/docs/guide/net/ipv6_guide/

    HP-UX 11.11 (11i v1) PA-RISC and 11.23 (11i v2) Itanium support dual protocol stacks IPv4 and IPv6. IPv6 is not currently supported on HP-UX 11.0 or 11.22 (11i v1.5). In this SDK release, the IPv4 protocol stack is the default. To support IPv6, HP-UX 11.11 (11i v1) requires patches; HP-UX 11.23 (11i v2) does not.

    To turn on IPv6 support, in addition to installing patches for HP-UX 11.11, you need to set the system property as follows:


    java.net.preferIPv4Stack=false

    Or at the Java command line you can use the option

    -Djava.net.preferIPv4Stack="false"

    For the availability of patches required for IPv6 support on HP-UX 11.11, please refer to

    » Patch Information
    » TOUR Transition Patches for HP-UX 11i

  • HP WDB: You can now use HP's debugger WDB 3.0.01 to examine backtraces containing mixed language frames (Java and C/C++) in Java thread stacks. This will simplify debugging the VM and Java mixed-language applications. In this release, only 32-bit mode is supported. For more information, see the "Usage Documentation" in these release notes.

  • -Xeprof option: Generates profile data for HPjmeter. See the section "HP Specific Options and Features" in these release notes for details.

  • -Xrs option: Reduces the use of operating-system signals by the Java virtual machine (JVM). See the section "Additional HotSpot Option Information" in these release notes for more information.

  • 3GB heap size: In this release, heaps up to 3GB are supported on HP-UX 11i with the installation of patches. Please see the section "Large Java Heap Sizes" in these release notes for details.

  • 64-bit mode (interpreter and compiler): Supported by using the option -d64. For further information, see "Additional HotSpot Option Information" in these release notes.

  • Java Web Start 1.2 is bundled with the SDK and RTE. For more information, see the Java Web Start release notes in javaws-1_2_0_00-hpux-PA_RISC.tar.Z and javaws-1_2_0_00-hpux-PA_RISC.tar.Z. The Java™ Web Start Downloads and Documentation.
  • installation

    patches 

    Operating system patches should be installed before you install the software. To determine which patches have been installed on your machine, login as root and check your machine with:

    /usr/sbin/swlist -l product

    For the most up-to-date list of required and recommended patches, and instructions on where to obtain them, go to the Java Required Patches page at:
    http://h18012.www1.hp.com/java/patches/index.html

    NOTE: Please install ALL dependency patches as well. These will be listed on the IT Resource Center web page from where you download the patch.

    minimum system recommendation 

    Users will get the best performance with PA-8600-based workstations, HP PA-RISC server series rp5400, rp7400, rp8400, and Superdome, with HP-UX 11.0 PA-RISC and 11i. The recommended minimum system for running Java applications is a PA-RISC 2.0 system.

    installation instructions 

    You need a total of approximately 160MB of disk space to download and install the .depot file. After installing the software, you can remove the .depot file.

    The HP-UX SDK, for the Java 2 Platform installs under /opt/java1.4. As root user, use the SD-UX swinstall command to install the software:

    /usr/sbin/swinstall

    It will lead you through the installation. Change Source Depot Type to "Local Directory" and Source Depot Path to /tmp/<filename>. (If you used a directory other than /tmp in the previous step, replace /tmp with that directory name.) We recommend you select the "Reinstall filesets" and unselect the "Mount filesystems" option from the options menu.

    WARNING: Do not unarchive rt.jar, charsets.jar, jpda.jar, tools.jar, jce.jar, and jsse.jar. These files are needed by the SDK tools and the runtime environment.

    Add the directory /opt/java1.4/bin to your PATH.

    Note: To install the software into an alternate location, see
    "Installing into an alternate location".

    For information on setting important system parameters required for correct execution of Java programs refer to the Programmer's Guide which can be found at Programmer's Guide for Java™ 2.

    Installing into an alternate location

    To install the software into an alternate location, add @/<alternatedirectory> to the end of the swinstall line, and add the alternate directory to your PATH.

    For example:

    /usr/sbin/swinstall -s <download> \* @/<alternatedirectory>

    Java prepends <alternatedirectory> to the default product path. Java will therefore install in /<alternatedirectory>/opt/java1.4.

    If you want your Java home directory in <alternatedirectory> without the /opt/java1.4 directories, you need to install into a temporary directory, and then move the directories to where you want them.

    For example:

    swinstall -s <download> \* @/<temporarydirectory>
    mv <temporarydirectory>/opt/java*/* <finalalternatedirectory>

    Or you can install and link to the directories.

    For example:

    swinstall -s <download> \* @/<actualdirectory>
    ln -s <finalalternatedirectory> /<actualdirectory>/opt/java*

    You will notice that the two files, <alternatedirectory>/etc and <alternatedirectory>/var are created. These may be purged, because they do not apply to a product installed in an alternate location.

    Note that we are testing another method of installing into an alternate location using <tag>. When we are confident that this method works with software depot install, we will post instructions here.

    file structure 

    The diagram below displays an abbreviated form of the file structure:
      java1.4
         |
      ___|_____________________________________________________
       |        |        |         |           |          |    
      bin      lib     *jre      src.zip      demo     include 
       |        |        |
      java    tools.jar  |
      javac   dt.jar     |
      javadoc ir.idl     |
      javah   orb.idl    |
      javap              | 
      jdb                |
                      ___|_______________
                         |               |
                        bin             lib
                         |               |
    ____________________ |____________   | 
    java PA_RISC PA_RISC2 PA_RISC2.0W    |  
                                         |
                                         |
                           _____|____________________________________
                           |      |    |       |        |           | 
                         rt.jar  zi security PA_RISC  PA_RISC2.0  PA_RISC2.0W
                      charsets.jar             |________|____________|  
                        jce.jar                |        |            |        
                        jsse.jar            server    server      server   
    

    * The files javaws-1_2_0_00-hpux-PA_RISC.tar.Z and javaws-1_2_0_00-hpux-PA_RISC.tar.Z are in the JRE directory, and contain Java Web Start technology 1.2. Web Start release notes are included in the tar.Z files. To extract a .tar.Z file, enter the command:

    zcat <filename> |tar -xvf

    The tools install under opt/java1.4/bin and the libraries install under opt/java1.4/lib. The tools.jar file contains the classes for supporting the tools and utilities. The file dt.jar contains the DesignTime archive of BeanInfo files.

    The jre directory includes the runtime environment. The file rt.jar contains the runtime classes for the core API. The file charsets.jar contains the internationalization and localization classes and files. The security directory contains security management files. The PA_RISC and PA_RISC2.0, and PA_RISC2.0W directories contain the shared libraries used by the HP-UX platform. The file src.zip contains an archive of source files for the core API for informational purposes. To extract the files, enter the command:

    $ unzip src.zip

    The include directory contains the header files for supporting JNI and JVMDI.

    usage documentation 

    The HP-UX Programmer's Guide for Java 2 provides additional information.

    The Java 2 Platform, Standard Edition, v 1.4 API Specification is provided at http://java.sun.com/products/jdk/1.4/docs/api/index.html.

    Below are the following additional documentation notes:

    supported tools and options 

    To run a tool on HP-UX, either use the full path name or add the path to the startup file. For example, for javac, on the command line you could enter: /opt/java1.4/bin/javac yourfile.java. You could alternatively add /opt/java1.4/bin to your PATH statement and on the command line enter:

    javac yourfile.java

    The HotSpot technology accepts all of the standard tools and options. The standard tools and the standard documentation references are noted below:

    The appletviewer tool is documented at:
    http://www.java.sun.com/products/jdk/1.4/docs/tooldocs/solaris/appletviewer.html

    CLASSPATH is documented at:
    http://www.java.sun.com/products/jdk/1.4/docs/tooldocs/solaris/classpath.html

    The extcheck tool is documented at:
    http://java.sun.com/reference/docs/index.html

    The idlj tool is documented at:
    http://java.sun.com/docs/index.html

    The jar tool is documented at:
    http://www.java.sun.com/products/jdk/1.4/docs/tooldocs/solaris/jar.html

    The jarsigner tool is documented at:
    http://java.sun.com/docs/index.html

    The java tool is documented at:
    http://www.java.sun.com/products/jdk/1.4/docs/tooldocs/solaris/java.html

    The javac tool is documented at:
    http://www.java.sun.com/products/jdk/1.4/docs/tooldocs/solaris/javac.html

    The javadoc tool is documented at:
    http://www.java.sun.com/products/jdk/1.4/docs/tooldocs/solaris/javadoc.html

    The javah tool is documented at:
    http://www.java.sun.com/products/jdk/1.4/docs/tooldocs/solaris/javah.html

    The javap tool is documented at:
    http://java.sun.com/docs/index.html

    The jdb (JPDA) tool is documented at:
    http://java.sun.com/docs/index.html

    The keytool tool is documented at:
    http://java.sun.com/reference/docs/index.html

    The native2ascii tool is documented at:
    http://java.sun.com/reference/docs/index.html

    The orbd tool is documented at:
    http://java.sun.com/j2se/1.4/docs/guide/idl/orbd.html

    The policytool tool is documented at:
    http://java.sun.com/reference/docs/index.html

    The rmic tool is documented at:
    http://java.sun.com/reference/docs/index.html

    The rmid tool is documented at:
    http://java.sun.com/reference/docs/index.html

    The rmiregistry tool is documented at:
    http://java.sun.com/reference/docs/index.html

    The serialver tool is documented at:
    http://java.sun.com/reference/docs/index.html

    The servertool is documented at:
    http://java.sun.com/j2se/1.4/docs/guide/idl/servertool.html

    The tnameserv tool is documented at:
    http://java.sun.com/reference/docs/index.html

    additional HotSpot option information 

    The HotSpot technology accepts all of the standard options as well as the following partial list of non-standard -X options. Non-standard options are subject to change in future releases.

    -d64
    Runs Java in 64-bit mode. See the section "64-bit support" under Known Issues in these release notes for more information on patches required.

    -X
    Prints out a brief usage message describing the non-standard options.

    -Xbatch
    Disables background compilation. If compilation of a large method is taking a long time, the performance engine will revert to interpreting the method. It will compile the method as a background task, running the method in interpreter mode until the background compilation is finished. The -Xbatch flag disables background compilation so that compilation of all methods proceeds as a foreground task until completed, regardless of how long the compilation takes. This flag is provided for users who desire more deterministic behavior of method compilation for purposes such as benchmarking.

    -Xbootclasspath: <bootclasspath>
    Specify a colon-separated list of directories, JAR archives, and ZIP archives to search for boot class files. The specified boot class libraries will be used instead of the boot class files in the jre/lib/rt.jar archive normally used by the Java 2 software.

    -Xincgc
    Enable the incremental garbage collector. The incremental garbage collector, which is off by default, will eliminate occasional garbage-collection pauses during program execution. However, it can lead to a roughly 10% decrease in overall performance. Note that -Xincgc is not supported on 32-bit PA-RISC in this release. Support will be available in a future SDK release.

    -Xint
    Operate in interpreted-only mode. Compilation to native code is disabled, and all bytecodes are executed by the interpreter. The performance benefits offered by the Java HotSpot adaptive compiler will not be present in this mode.

    -Xmn
    Set the Java new generation heap size (for example: -Xmn64m). The "new generation" is the first generation in HotSpot's generational garbage collector. This option replaces the option -XX:NewSize=N.

    -Xms<size>
    Specify the initial size, in bytes, of the memory allocation pool. This value must be a multiple of 1024 greater than 1MB. Append the letter k or K to indicate kilobytes, or m or M to indicate megabytes. The default value is 5248KB. Examples:

    -Xms4194304
    -Xms4096k
    -Xms4m

    -Xmx
    Specify the maximum size, in bytes, of the memory allocation pool. This value must be a multiple of 1024 greater than 2MB. Append the letter k or K to indicate kilobytes, or m or M to indicate megabytes. The default value is 64MB. Examples:

    -Xmx83886080
    -Xmx81920k
    -Xmx80m

    -Xnoclassgc
    Disables class garbage collection.

    -Xprof (Excerpt below from Sun Microsystems' documentation.)
    Profiles the running program, and sends profiling data to standard output. This option is provided as a utility that is useful in program development and is not intended to be be used in production systems.

    -Xrs (beginning with SDK 1.3.1)
    Reduces use of operating-system signals by the Java virtual machine (JVM), allowing for orderly shutdown of a Java application. Allows user cleanup code (such as closing database connections) to run at shutdown, even if the JVM terminates abruptly. For more information, see Javasoft's documentation at: http://java.sun.com/j2se/1.3/docs/tooldocs/solaris/java.html.

    -Xss<size>
    Specify the size of stack for each new Java thread. The default Java thread stack size is 512KB. This flag is appropriate for programs that have small thread stack size requirements and/or create several thousand threads, potentially running out of virtual memory. Program threads that overflow the allocated stack will receive java.lang.StackOverFlowException.

    Defaults: -Xss512k (Java 1.3 and 1.4 32-bit mode)
      -X1m (Java 1.4 64-bit mode)
    -XX:+AllowUserSignalHandlers
    Instructs the HotSpot JVM option not to complain if the native code libraries install signal handlers. This only matters if the handlers were installed when the VM is booting.

    -XX:+DisableExplicitGC
    Disable calls to System.gc(). The JVM still performs garbage collection when necessary.

    -XX:MaxNewSize=<size>
    Sets the maximum size of new generation (in bytes). Note that in HotSpot 1.0.1 this option took an integer that specified a value in Kbytes. Starting with HotSpot 1.3.1, the integer argument specifies bytes. The arguments can now be followed by either 'k' or 'm' to specify Kbytes or Mbytes.

    -XX:NewSize=<size>
    Sets the default size of new generation (in bytes). Note that in HotSpot 1.0.1 this option took an integer that specified a value in Kbytes. Starting with HotSpot 1.3.1, the integer argument specifies bytes. The arguments can now be followed by either 'k' or 'm' to specify Kbytes or Mbytes.

    -XX:NewSizeThreadIncrease=<sizeInKb>
    Sets the additional size added to desired new generation size per non-daemon thread (in bytes). Note that in HotSpot 1.0.1 this option took an integer that specified a value in Kbytes. Starting with HotSpot 1.3.1, the integer argument specifies bytes. The arguments can now be followed by either 'k' or 'm' to specify Kbytes or Mbytes.

    -XX:MaxPermSize=<size>
    Sets the maximum size of permanent generation (in bytes). Note that in HotSpot 1.0.1 this option took an integer that specified a value in Kbytes. Starting with HotSpot 1.3.1, the integer argument specifies bytes. The arguments can now be followed by either 'k' or 'm' to specify Kbytes or Mbytes.

    -XX:+ServerApp
    A set of XX options which, when bundled together, make some applications run faster. For each release, the options as well as the values may be different depending upon the default values of XX options. We recommend that you test to see whether this set enhances the performance of your application before you use the option in production.

    -XX:SurvivorRatio=<size>
    Ratio of eden/survivor space size. Default for SDK 1.4 is 64MB. Number can include 'm' or 'M' for megabytes, 'k' or 'K' for kilobytes, and 'g' or 'G' for gigabytes. For example, 32k is the same as 32768.

    -XX:+UseCompilerSafepoints
    Enables compiler safe points. In this version, compiler safe points is off by default. Enabling compiler safepoints guarantees a more deterministic delay to stop all running java threads before doing a safepoint operation, namely garbage collection and deoptimization. For patch information, see "Known Problems" in these release notes.

    -XX:+UseOnStackReplacement
    Enables on stack replacement. In this version, on stack replacement is off by default. On stack replacement enables the interpreter to go into compiled code while it is executing the same instance of the method call. For example, if the VM is executing a method that has a loop with a large number of iterations, an intra-method hotspot will occur. To get better performance, the method should run in compiled mode instead of interpreted mode. If you enable on stack replacement, you should also enable compiler safe points (see the previous section). For patch information, see "Known Problems" in these release notes.

    -XX:+UseSIGUSR2
    Use the java command line option -XX:+UseSIGUSR2 if you want the JVM to use SIGUSR2 for internal operations like Thread.interrupt() calls instead of SIGUSR1, the default. This allows you to better implement third party middleware applications that in some versions want to use SIGUSR1 for similar purposes in their native code.

    HP specific options and features 

    Additional HP specific documentation is provided in the Programmer's Guide for Java™ 2.

    Noteworthy HP specific options and features for Java 2 version include the following:

  • -pa11
  • -Xeprof
  • -Xnocatch
  • -Xprep
  • -verbosegc
  • -Xverbosegc
  • These are described below.

    -pa11 option
    HP's PA-RISC 2.0 architecture offers performance features not compatible with previous architectures. PA1.1 binaries can be run on PA1.1 as well as PA2.0 based systems; however, a PA2.0 binary can only run on a PA2.0 based system. Starting with the 1.2.2 release of the SDK, HP includes two versions of the shared libraries comprising APIs and VMs. The PA2.0 shared libraries will be default if the user is running on a PA2.0 system. The user can override the use of the PA2.0 version of the shared libraries on a PA2.0 by specifying the -pa11 flag. For example:

    On a PA2.0 based system, invoking Java by typing
    java -version

    results in something similar to:
    java version "1.4.0"
    HotSpot VM (..., mixed mode, PA2.0 build 1.4.00-00/04/23-PA_RISC 2.0)

    The generated version string indicates that the PA2.0 version of the VM will be used.

    You can override the use of the PA2.0 version of the VMs and APIs on a PA2.0 system by adding the -pa11 flag as follows:
    java -pa11 -version

    This results in something similar to:
    java version "1.4.0"
    HotSpot VM (..., mixed mode, PA1.1 build 1.4.00-00/-4/23-PA_RISC 1.1)

    The version string indicates that the PA1.1 version of the VM in spite of the fact that you are running on a PA2.0 system.

    Note: If you run HotSpot with the -pa11 flag or run on a PA 1.1 system, your heap address space will be restricted to 1G.

    -Xeprof option
    The -Xeprof option generates profile data for HPjmeter. The -Xeprof option enables profiling of Java applications running on HotSpot version 1.2.2.05 or greater and collects method clock and CPU times, method call count, and call graph. (For more information on HPjmeter, see HPjmeter Downloads and Documentation.)

    To profile your application use the following command:
    java -Xeprof:<options> ApplicationClassName

    To profile your applet, use:
    appletviewer -J-Xeprof:<options> URL>

    where <options> is a list of <key>[=<value>] arguments separated by commas.

    After the profiled applet or application normally terminates execution, the Java Virtual Machine writes the profile data to a file in the current directory.

    We have found the following options useful in most cases:

    For CPU time metrics with minimal intrusion:
    -Xeprof
    or
    -Xeprof:ie=no

    Exact call count information and object creation profiling:
    -Xint -Xeprof:ie=no

    To see the complete list of available options, use
    java -Xeprof:help

    » supported -Xeprof options

    -Xnocatch
    The -Xnocatch option disables the Java "catch-all" signal handler. Use this option to generate clean stack traces from native code.

    -Xprep
    The -Xprep option is used to dynamically preprocess (modify) bytecodes of the classes loaded by the VM. Its syntax is:
    -Xprep <factory_class_name>:<arguments>

    where <factory_class_name> is a qualified name of the class that will be used to create the preprocessor, and <arguments> is any string that will be passed to the method creating the preprocessor.

    When the -Xprep option is specified, before loading the application classes, the Java VM will load the specified factory class and execute the method in the class declared as:
    public static Preprocessor createPreprocessor (String arg)

    where Preprocessor is an interface defined as:
    package hp.javatools.bytecode;
    public interface Preprocessor {
    public abstract byte[] instrument (String name, byte[] klass); }

    The VM will pass the <arguments> specified in the -Xprep option to the createPreprocessor method as its only argument. The Preprocessor object returned by the invocation will be saved by the VM.

    For each subsequently loaded class, the VM will invoke the instrument method on the Preprocessor object, passing the name of the class being loaded, and the bytecode representation of the class. The returned array of bytes will be used by the VM as the replacement of the original version of the class. If null is returned, the original version of the class will be used.

    -verbosegc or -verbose:gc
    Prints out the result of a garbage collection to the stdout stream. At every garbage collection, the following 5 fields are printed:
    [%T %B->%A(%C), %D]
    

    %T is "GC:" when the garbage collection is a scavenge, and "Full GC:" when its a full garbage collection. A scavenge collects live objects from the New Generation only, whereas a full garbage collection collects objects from all spaces in the Java heap.

    %B is the size of Java heap used before garbage collection, in KB.

    %A is the size after garbage collection, in KB.

    %C is the current capacity of the entire Java heap, in KB.

    %D is the duration of the collection in seconds.

    -Xverbosegc<options>
    To better understand how garbage collection works in the HotSpot JVM, we recommend the article "Improving Java Application Performance and Scalability by Reducing Garbage Collection Times and Sizing Memory Using JDK 1.4.1" (November 2002) by Nagendra Nagarajayya and J. Steven Mayer. The article describes garbage collectors in SDK 1.4.x, however it also covers the older collectors used in 1.3.x.

    In addition, we recommend HP's tool HPjtune, which graphically displays information contained in an Xverbosegc log.

    The -Xverbosegc option prints out detailed information about the spaces within the Java Heap before and after garbage collection.

    The syntax is:

    -Xverbosegc usage: -Xverbosegc[:help]|[0|1][:file=[stdout|stderr|<filename>]]
    
        :help prints this message.
    
        0|1 controls the printing of heap information:
            0   Print after every Old Generation GC or Full GC
            1   (default) Print after every Scavenge and Old Generation GC 
                or Full GC
    
    
        :file=[stdout|stderr|<filename>] specifies output file
            stderr    (default) directs output to standard error stream
            stdout     directs output to standard output stream
            <filename> file to which the output will be written
    
    At every garbage collection, the following 20 fields are printed:
    <GC: %1 %2 %3 %4 %5 %6 %7 %8 %9 %10 %11 %12 %13 %14 %15 %16 %17 %18 %19 %20>
    

    » -Xverbosegc:help detailed explanation

    FastSwing
    FastSwing is an HP feature which provided significant performance improvement for Swing Applications on a Remote X-Server. In this release, the FastSwing option is ignored by the HP SDK 1.4. The Java 1.4 performance enhancements provide out-of-the-box performance for both local and remote displays, equivalent to FastSwing. For more information on 1.4 performance enhancements, see:
    http://java.sun.com/products/java-media/2D/perf_graphics.html

    new garbage collectors: parallel and concurrent mark and sweep

    JavaSoft has implemented new generational collectors that emphasize the throughput of the application or low garbage collection pause times. In testing, HP has found that the new collectors are more stable in SDK 1.4.2 than in 1.4.1. We therefore recommend that if you wish to use this new generation of garbage collectors, you upgrade to SDK version 1.4.2.

    large java heap sizes: expanding heap size in native applications
    (HP-UX 11.0 and 11i)
     

    If you embed libjvm in a native application, and wish to use a large Java heap, you need to ensure that enough private data space is enabled. On HP-UX 11.0 and 11i, by using HP-UX's EXEC_MAGIC linked with "-N" you can expand your available memory space from 1GB to around 1.7GB.

    HP-UX 11.0
    With the installation of the required patches shown below (or their superseded patches), you can get larger Java heap by using the command below.

    Required Patches: PHKL_27282, PHKL_23409, PHKL_28180, PHKL_26136
  • For 1500MB to 2400MB of Java heap:
    chatr +q3p enable <executable name>
  • HP-UX 11i (11.11)
    With the installation of the required patch shown below, you can get larger Java heap by using the commands below.

    Required Patch: PHKL_28267 (or its superseded patch)
  • For 1500MB to 2400MB of Java heap:
    chatr +q3p enable <executable name>

  • For 2400MB to 3.8GB of Java heap:
    chatr +q3p enable +q4p enable <executable name>
  • See also "Application Dependent Considerations When Using Large Heap Size" in these release notes.

    large java heap sizes: expanding heap size (HP-UX 11i) 

    Hotspot 1.4.1 now supports heaps up to 3.0GB on HP-UX 11i, with the installation of the patch shown below.

    For Java invoked from the command line on HP-UX 11i, Java will automatically choose an appropriate executable.

    Required patch: PHKL_28267 (or its superseded patch)
  • For heaps less than 1500MB, the executable is 'java'.

  • For heaps greater than or equal to 1500MB, and less than 2400MB the executable is 'java_q3p.

  • For heaps of 2400MB to 3.8GB*, the executable is 'java_q4p'.
  • You do not need to directly invoke these programs. Just invoke 'java' as usual, and the appropriate program will be run for you.

    In addition, be aware that if you wish to use very large heaps, because of segmentation in the HP-UX virtual address space, when the Java heap is larger than 3000MB, either new space (-Xmn) or old space (-mx minus -Xmn) must be approximately 850MB or less.

    See also the next section,
    "Application Dependent Considerations When Using Large Heap Size."

    application dependent considerations when using large heap size 

    Thread stacks and C heap are allocated from the same address space as the Java heap, so if you set the Java heap too large, new threads may not start correctly. Or some other part of the runtime or native methods may suddenly fail if the C heap cannot allocate a new page. An application may start up correctly with a 1.7GB heap, but this does not necessarily mean it's going to work correctly.

    For example, if you use a 1MB stack size, and have about 80 threads in the process, you will have 80MB for stacks. If you have native libraries, you would probably add another 64MB for C heap. You have now used a total of 144MB of your heap for other things.

    Since all programs have varying C heap requirements and have varying numbers of threads, it's difficult to ascertain what the effect will be of running the application at its limit. It's important to understand the real requirements of your application. We recommend that you perform sizing tests before deployment with a realistic load, while monitoring with the -Xverbosegc option and a tool like GlancePlus.

  • For more on the -Xverbosegc option, go to the HotSpot chapter of the HP-UX Programmer's Guide for Java 2 at: http://docs.hp.com/en/JAVAPROGUIDE/hotspot.html

  • For more information on GlancePlus, go to: http://www.openview.hp.com/products/gplus/index.html

  • For more information on performance tuning Java on HP-UX, refer to our Performance Tuning website
  • using WDB to examine backtraces in Java thread stacks  

    You can now use HP's debugger WDB 3.0.01 (the Gnu Debugger gdb) to examine backtraces containing mixed language frames (Java and C/C++) in Java thread stacks. This will simplify debugging the VM and Java mixed-language applications. Set the environment variable GDB_JAVA_UNWINDLIB to the pathname of the Java Unwind Shared Library libjunwind.sl (PA), which is in the SDK.

    The default location of the Java Unwind Library in the SDK is:

    /opt/java1.4/jre/lib/PA_RISC/server/libjunwind.sl
    /opt/java1.4/jre/lib/PA_RISC2.0/server/libjunwind.sl
    /opt/java1.4/jre/lib/PA_RISC2.0W/server/libjunwind.sl

    For example, in ksh, you should set the environment variable like this:

    For PA1.1 machines:

    export GDB_JAVA_UNWINDLIB=/opt/java1.4/jre/lib/PA_RISC/server/libjunwind.sl

    For PA2.0 machines:

    export
    GDB_JAVA_UNWINDLIB=/opt/java1.4/jre/lib/PA_RISC2.0/server/libjunwind.sl

    For 64-bit PA2.0 machines:

    export
    GDB_JAVA_UNWINDLIB=/opt/java1.4/jre/lib/PA_RISC2.0W/server/libjunwind.sl

    If you installed the SDK in a location other than the default, you would substitute the non-default location for "/opt/java1.4" in the above commands. Then use WDB as usual to debug your Java applications or core files. See the tutorial slides on Debugging Performance Tuning, Tutorials, & Training (.pdf) for help on how to use the new Java stack unwind functionality.

    Asian TrueType fonts and Asian locales 

    The SDK now supports HP-UX Asian TrueType fonts, with the installation of patches.

    For information on which HP-UX patches you need for each language and for additional documentation on fonts, please see the document HP-UX Fonts and the Java™ Runtime Environment.

    The following Asian Locales are now supported by HP's 1.4 SDK with TrueType fonts.

    ja_JP.SJIS   Japanese with Shift-JIS encoding
    ja_JP.eucJP   Japanese with JIS EUC encoding
    ko_KR.eucKR   Korean with KSC5601 EUC encoding
    zh_CN.gb18030   simplified Chinese with GB18030 encoding
    (supported only on HP-UX 11i)
    zh_CN.hp15CN   simplified Chinese, with GB2312 EUC encoding
    zh_TW.big5   traditional Taiwan Chinese with Big5 encoding
    zh_TW.eucTW   traditional Taiwan Chinese with CNS11643 encoding
    (planes 1-3)
    zh_HK.hkbig5   traditional HongKong Chinese with Big5 HK encoding
    In HP-UX Fonts and the Java™ Runtime Environment you will find information on the following topics:

    » X Windows, Java applications and TrueType fonts
    » installing Asian TrueType fonts
    » the hp.fontpath property
    » bitmap vs. scalable fonts
    » the JAVA_FONTS environment variable
    » how the X font server affects font display
    » controlling the X font server

    date/time methods - new defaults 

    Since SDK 1.2.2.09 and SDK 1.3.1, there has been a change in the way the HotSpot JVM uses the gettimeofday() system call to obtain date and time information.

    For performance reasons a new mechanism is used that uses the number of cpu ticks since the application started, to calculate the current time. As a result, changes to the system date or time using date(1), adjtime(2) or time synchronization utilities such as ntp will not be reflected in the date and time that Java returns, until the process is restarted.

    If your application requires that Java immediately reflects such system time changes, you can use the -XX:+UseGetTimeOfDay option to tell the JVM to use the gettimeofday call instead of the new, lightweight mechanism. However you may notice a drop in performance,

    profiling capability added 

    In the SDK version 1.4, a SIGPROF handler to support future profiling capability is installed automatically. This may cause incompatibilities with other native code or profiling tools which use SIGPROF.

    You can turn off the SIGPROF handler by using the following option:

    -XX:+ReduceSignalUsage

    However you should be aware that using this option also turns off the SIGQUIT handler. Therefore you will not be able to get a Java stack trace.

    signal chaining functionality 

    1.4 has a new feature for chaining an application's signal handlers behind the JVM's signal handlers. With signal chaining functionality, applications can now use signals that the JVM uses and not interfere with the JVM's functionality. To obtain this functionality, you need to install a patch (described below).

    For signal chaining functionality, the application must load the library libjsig.sl before libc.2.

    libjsig.sl takes care of signal chaining when the application's signal handlers are installed before or after the VM's handlers get installed. libjsig.sl is not needed when the application installs the handlers before the JVM installs its handlers.

    There are two cases to consider.
    1. Native application creates a JVM
      The application can either link in libjsig.sl and ensure that libjsig.sl gets loaded before libc.2 by linking them in the right order or use the LD_PRELOAD functionality provided by the linker to load libjsig.sl first.

    2. Normal JAVA application invoked from the command line LD_PRELOAD must be used in this case. Linking the native libraries with libjsig will not work because the JVM will load libc.2 before the application's shared libraries get loaded.

      For example, to use the LD_PRELOAD environment variable:

      export LD_PRELOAD=<libjvm.sl dir>/libjsig.sl; java_application (ksh)
      setenv LD_PRELOAD=<libjvm.sl dir>/libjsig.sl; java_application (csh)

    To obtain the LD_PRELOAD functionality, you need to install the patch shown below.
  • HP-UX 11.00 systems, install patch PHSS_26559 (or the patch that supersedes it)

  • HP-UX 11.11 systems, install patch PHSS_26560 (or the patch that supersedes it)
  • For more information on signal chaining, go to
    http://java.sun.com/j2se/1.4/docs/guide/vm/signal-chaining.html

    using JNI - main/primordial thread stack size limits

    The primordial thread is the first thread when a process is created. This is the thread that has the main method. It is also called the main thread. The primordial thread stack size is controlled by the kernel parameter maxssiz or maxssiz_64bit. The Java VM (JVM) has two options for controlling the stack size:

    -XX:MainThreadStackSize=n
    -Xss[n][k or m]

    In the Java VM the size of the primordial thread is restricted to the *greater* of MainThreadStackSize (default 2M) or ThreadStackSize (specified by -Xss). For example, if you specify -Xss1m, the JVM still takes 2M for the main thread. And if you specify -Xss4m, the JVM takes 4M for the main thread as well.

    If your application calls JNI_CreateJavaVM or JNI_AttachCurrentThread from the primordial thread, under certain conditions the stack usage could cross the JVM-imposed primordial thread stack size limit of 2M and cause a stack overflow situation in the native code itself, even if no Java code was ever run on the primordial thread.

    One workaround is to use the option -XX:MainThreadStackSize=<value> to increase the primordial thread stack size, However be aware that -XX options are non-standard options, and are liable to change from release to release.

    Other workarounds and examples are provided in our Programmer's Guide along with the effects of using maxssiz on the amount of writeable data space available to the application. Refer to the JNI chapter of our Programmer's Guide for Java 2 at: Using Java™ 2 JNI on HP-UX

    using JNI - non-main/primordial thread stack size limits

    The default stack size for 1.4 64-bit mode JVM- created threads is 1MB. On PA-RISC 32 and 64-bit systems, the default stack size is 64KB. Therefore, if you are using C language main programs that attach with JNI, you will want to adjust the stack size to avoid overflows.

    Here are some suggestions to work around stack overflow problems in threads other than the main thread:

  • If the thread is created in native code and is attached to Java through JNI_AttachCurrentThread, increase the stack size attribute when creating the thread with pthread_create.
  • If the thread is created inside Java and there is a stack overflow condition, increase the thread stack size with -Xss<n>
  • using JNI—dereferencing NULL pointers 

    In Java 2, JNI code that incorrectly dereferences NULL will result in a SIGSEGV, which may be different behavior than that experienced with Java 1.1 releases. For example, in Java 1.1, JNI methods that dereference NULL pointers like this:

    int *p = NULL;
    return *p;

    will return the value 0.

    With the Java 2 the HotSpot VM, such dereferences result in a SIGSEGV, and java NULL checks can be performed without having to emit explicit code to do so. With Java 2 HotSpot, the signal is caught, and a null pointer exception is thrown if the offending instruction was within the VM (compiled code, or in the interpreter). This method may uncover hidden programming errors.

    Also, if you are including the HP-UX Runtime Environment for the Java 2 Platform in an application and bypassing our standard driver, for example by making calls to JNI_CreatJavaVM from inside the application, link the application with the "-z" option. The -z option will indicate that dereferencing NULL pointers in the application should generate a SIGSEGV instead of the traditional behavior of returning zero. If you do not, you will not be able to take advantage of implicit null pointer checks; null pointer checks will have to be explicit, potentially degrading performance. Linking with -z may also expose existing but quiet bugs in an application. This is because the SIGSEGVs were not being generated before.

    manually launching the application VM 
    (excerpted from http://java.sun.com/products/jpda/readme.html)

    If you are running the version of jdb provided in this release, the application VM is launched for you with the debugger back end loaded. However, in the following cases, you will be launching your own application VM, either by hand or in your implementation.
    1. Remote debugging with the -attach or -listen jdb option.
    2. You are implementing a debugger which uses the JDWP directly.
    3. You are implementing a debugger back end which uses JVMDI.

    Currently, the first two cases require a command line like the following:

    java -Xdebug -Xnoagent -Djava.compiler=NONE
    -Xrunjdwp:transport=dt_socket,server=y,suspend=y
    -classpath class-path class-name

    The -Xdebug option enables debugging. The -Xnoagent disables the default sun.tools.debug debug Agent. The -Djava.compiler=NONE disables the JIT compiler.

    For the third case, you must use the same command line options as described above, but you are free to use your own mechanism for loading the JVMDI client into the application VM. You do not need to use -Xrun.

    The Connection and Invocation Details document at http://java.sun.com/products/jpda/doc/conninv.html contains more information on necessary VM invocation options and sub-options of -Xrunjdwp.

    Closing a socket when accept or read is pending (PA-RISC & Itanium) 

    If you have a thread performing an accept or read/write on a socket, and you try to close the socket to clean up resources, the default behavior is for the close() to block until the accept or read/write call completes. If you want to change this behavior, you can use the following Java command line option:

    -XdoCloseWithReadPending

    This option allows a thread to close a socket when there is an outstanding accept or read pending on the same socket from another thread.

    With the -XdoCloseWithReadPending option, the socket close() call closes the socket and, in the context of the thread with the pending read or accept, a SocketException with the message "Socket closed" is thrown.

    C and C++ libraries 

    Libraries compiled with the cfront HP C++ compiler will not work with HotSpot. HotSpot requires use of the HP a C++ compiler for any application C++ libraries loaded dynamically at runtime.

    JAR files 

    If you run an applet from a JAR file, the classes files should only be available in the JAR file, and the JAR file should not be in the class path.

    compatibility with previous releases 

    Sun Microsystems maintains upward compatibility (except for noted incompatibilities). Therefore an application written for 1.3 will run on a 1.4 JVM. Downward compatibility is generally not supported, since new APIs are introduced that cannot be run in 1.3.

    For a detailed description of the incompatibilities between 1.3 and 1.4, go to:
    http://java.sun.com/j2se/1.4/compatibility.html

    web sites with more information 

    The following websites have additional information:

    Java 2 SDK version 1.4 features and tools:
    java.sun.com/products/j2se/1.4/docs/index.html

    Java 2 SDK version 1.3 features and tools:
    http://java.sun.com/reference/docs/index.html

    Java 2 version 1.4 API Specification:
    http://java.sun.com/products/j2se/1.4/docs/api/index.html

    Java 2 platforms and APIs—Authorized Books:
    http://java.sun.com/docs/books/index.html

    Java tutorial:
    http://java.sun.com/docs/books/tutorial/index.html

    Java Security:
    http://java.sun.com/security/index.html

    Java Technologies:
    http://java.sun.com/products/

    Swing Connection newsletter:
    http://java.sun.com/products/jfc/tsc/index.html

    problem fixes and known issues 

    problem fixes

    Known JavaSoft bugs are documented in the Bug Database at http://developer.java.sun.com/

    This release includes defects fixed in 1.3.1 and 1.4 releases, as well as the following enhancement request.

    JAGae23748 HP SR 8606259430   Enhancement: Enable support for UDP DatagramSocket connections w/ ICMP
    known issues 

    Below is some information on known defects. Some of the solutions require installing patches. For information on locating and installing the patches, go to Patch Information.

    using the C++ (-AA) option (PA-RISC only) 
    If you are running HP-UX 11.0 or 11.11 PA-RISC, you cannot use the ANSI C++ standard (-AA) option in an application that loads Java. Starting with SDK 1.4.1.03, there is a workaround for this problem.

    NOTE: This only affects PA-RISC systems; on Itanium systems, the C++ runtime libraries are designed to support -AA by default.

    For more information on HP's Classic C++ runtime and the Standard C++ runtime environments refer to "Development Tools and Distributed Computing".

    GUI applications get warnings due to logging 
    Due to a known JavaSoft problem (ID 4398496), when running GUI applications with 1.4.1 you might encounter the following error messages:

    "java.util.prefs.FileSystemPreferences$3 run
    WARNING: Could not create system preferences directory.
    System preferences are unusable."

    Or:

    "java.util.prefs.BackingStoreException:
    Couldn't get file lock."

    The workaround follows. As root, create a directory /etc/.java on the system encountering the error. You can do this manually , or by running any java program as root. This creates a /etc/.java/.systemPrefs file, which solves the problem.

    HPjtune 
    HPjtune will not display data for SDK and RTE 1.4.1, due to a defect. This is expected to be fixed in a future release.

    default, parallel-scavenge, and concurrent mark sweep GC 
    1.4.1 supports two heaps (default and parallel-scavenge), and three different collections (default, parallel scavenge, and concurrent mark sweep). Because of a defect, only the default GC in the default heap is supported in this 1.4.1.00 release. Quadrant 4 (q4p) is enabled by default, and parallel GC and concurrent mark-sweep GC do not work in 1.4.1.00 with q4p enabled. It is planned that these collections will be supported in 1.4.1.01.

    shl_load HotSpot libjvm problem due to TLS 
    The libjvm library for the HotSpot 1.4 JVM uses thread local storage (TLS). Currently the dynamic loader that is used by shl_load does not support dynamically loading a shared library containing TLS when the library was not included in the link line.

    You may have a need to load a library dynamically (using shl_load or dlopen) that contains TLS, for example libjvm.sl, without having linked your application against it. For example, this might be the case if your application uses plug-ins.

    The current workaround is a new linker feature LD_PRELOAD that is available for HP-UX 11.0 in patch PHSS_26559. For HP-UX 11i the feature will be included in the next update release. For more information on LD_PRELOAD functionality and its limitations, read the man page for dld.sl AFTER you have installed the patch.

    64-bit support - X/Motif 
    For 64-bit support on X/Motif, you will need to install one of the patches shown below.

    HP-UX 11.00 PHSS_27232 64-bit
    HP-UX 11.11 PHSS_27425 32/64-bit

    These fix GUI failures due to the window height of some Java application pop-up windows being too large.

    64-bit support - system call 
    The system call get__lwFastHighResolutionTimer() may fail. For HP-UX 11.0, the workaround is to install the two patches shown below. HP-UX 11i (11.11) system calls function correctly.

    HP-UX 11.00 PHKL_27510 __lw_get_thread_times reports incorrect time
    HP-UX 11.00 PHKL_26008 cumulative pstat patch

    /dev/poll runtime support 
    For systems where /dev/poll runtime support is required, you will need to install one of the following patches, depending on your HP-UX version:

    HP-UX 11.0 PHKL_24064
    HP-UX 11i  PHKL_25468

    HPjconfig configuration tool 
    HPjconfig version 2.0 or earlier will not work with 1.4 JVM. HPjconfig version 2.0.2 fixes this problem. It is available at HPjconfig Downloads and Documentation.

    on stack replacement 
    For both HP-UX 11.0 and 11i, using on stack replacement requires a patch. The required patch numbers are shown below. For information on locating and installing the patches, go to Patch Information.

    HP-UX 11.0  PHKL_28152 PHKL_28152
    HP-UX 11.11 PHKL_24751 PHKL_27317

    In this version, on stack replacement is off by default. To enable it, use the -XX:+UseOnStackReplacement option.

    If the VM is executing a method that has a loop with a large number of iterations, an intra-method hotspot will occur. In order to get better performance, the method should run in compiled mode instead of interpreted mode. On stack replacement enables the interpreter to go into compiled code while it is executing the same instance of the method call. If you use on stack replacement, you should also enable compiler safe points (see the next section).

    HotSpot compiler safe points 
    For both HP-UX 11.0 and 11.11, using Compiler Safe Points requires a patch. The required patch numbers are shown below. For information on locating and installing the patches, go to Patch Information.

    HP-UX 11.0 PHKL_28152 PHKL_28152
    HP-UX 11i  PHKL_24751 PHKL_27317

    In this version, compiler safe points is off by default. To turn it on, use the -XX:+UseCompilerSafepoints option. Enabling compiler safepoints guarantees a more deterministic delay to stop all running java threads before doing a safepoint operation, namely garbage collection and deoptimization.

    secure socket layer (SSL) connections 
    When using an SSL connection to a web server, you need to run your Java application with the additional option shown below. This is due to a defect, which will be fixed in the next 1.4 release.

    -Djava.protocol.handler.pkgs="sun.net.www.protocol

    using linker option +noenvvar on Itanium and PA-64 systems 
    If your application links with libjvm and uses the JNI interface APIs to load the JVM directly, do not use the linker option +noenvvar on Itanium or PA-64 systems. The defect does not exist on 32-bit systems. It is expected to be fixed in a future release.

    running Java with setuid or setgid 
    Java requires dynamic loading (SHLIB_PATH, LD_LIBRARY_PATH) which are disabled in setuid or setgid executables. Therefore Java cannot run with setuid or setgid.

    running Aries Itanium emulation on PA2.0
    If you are running the Aries Itanium emulator on a PA2.0 system with HP-UX 11.22 or 11.23, a defect exists which causes Java math calculations to produce incorrect math routine results.

    This problem applies to those applications that do Java math calculations, specifically any that use the constant Float.MAX_VALUE, or a floating point value that is the maximum floating value.

    Because the same Java math calculations are used in the GUI code, applications that use GUIs will also be affected.

    This problem is fixed by installing the following patches:

    HP-UX 11.22: PHSS_29654
    HP-UX 11.23: PHSS_29658

    legal notices

    Copyright © Hewlett-Packard Company 2003.
    All Rights Reserved. Reproduction, adaptation, or translation without prior written permission is prohibited, except as allowed under the copyright laws.

    UNIX is a registered trademark in the United States and other countries, licensed exclusively through X/Open Company Limited.

    WHILE THE INFORMATION IN THIS PUBLICATION IS BELIEVED TO BE ACCURATE, HEWLETT-PACKARD MAKES NO WARRANTY OF ANY KIND WITH REGARD TO THIS MATERIAL, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Hewlett-Packard shall not be liable for errors contained herein or for incidental or consequential damages in connection with the furnishing, performance or use of this material. Information in this publication is subject to change without notice.

    Java and all Java-based trademarks and logos are trademarks or registered trademarks of Sun Microsystems, Inc. in the U.S. and other countries.